CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
Functions
RemoteMonitoringMAPTEST.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 34 of file RemoteMonitoringMAPTEST.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.

34  {
35  std::string dirnm = "Analyzer";
36  gROOT->Reset();
37  gROOT->SetStyle("Plain");
38  gStyle->SetOptStat(0);
39  gStyle->SetOptTitle(1);
40  // ok change
41  if (argc < 3)
42  return 1;
43  char fname[300];
44  char refname[300];
45  char runtypeC[300];
46  sprintf(fname, "%s", argv[1]);
47  sprintf(refname, "%s", argv[2]);
48  sprintf(runtypeC, "%s", argv[3]);
49  std::cout << fname << " " << refname << " " << runtypeC << std::endl;
50  // ok change
51 
52  //======================================================================
53  // Connect the input files, parameters and get the 2-d histogram in memory
54  // TFile *hfile= new TFile("GlobalHist.root", "READ");
55  string promt = (string)fname;
56  string runtype = (string)runtypeC;
57  string runnumber = "";
58  for (unsigned int i = promt.size() - 11; i < promt.size() - 5; i++)
59  runnumber += fname[i];
60  string refrunnumber = "";
61  promt = (string)refname;
62  for (unsigned int i = promt.size() - 11; i < promt.size() - 5; i++)
63  refrunnumber += refname[i];
64 
65  TFile *hfile = new TFile(fname, "READ");
66  hfile->ls();
67  TDirectory *dir = (TDirectory *)hfile->FindObjectAny(dirnm.c_str());
68  TFile *hreffile = new TFile(refname, "READ");
69  hreffile->ls();
70  TDirectory *refdir = (TDirectory *)hreffile->FindObjectAny(dirnm.c_str());
71 
72  // with TfileService implementation, change everywhere below: hreffile->Get to refdir->FindObjectAny
73  // with TfileService implementation, change everywhere below: hfile->Get to dir->FindObjectAny
74 
75  double MIN_M[7][5];
76  double MAX_M[7][5];
77  double MIN_C[7][5];
78  double MAX_C[7][5];
79  double porog[5];
80  double Pedest[2][5];
81 
82  if (runtype == "LED") {
83  //CUTS: [test][subdetector] ADC amplitude Am Width for Wm Ratio cut for Rm TS mean for TNm TS max for TXm
84  double MIN_M_LED[7][5] = {{0., 0., 0., 0., 0.},
85  {0., 0., 0., 0., 0.},
86  {0, 100., 70., 40., 40.},
87  {0, 0.7, 0.7, 0.1, 0.1},
88  {0, 0.7, 0.6, 0.40, 0.45},
89  {0, 2.5, 1.0, 1.0, 1.0},
90  {0, 1.5, 1.5, 0.5, 0.5}};
91  double MAX_M_LED[7][5] = {{0., 0., 0., 0., 0.},
92  {0., 0., 0., 0., 0.},
93  {0, 3000, 500000, 3000, 150000},
94  {0, 2.5, 2.5, 2.8, 2.6},
95  {0, 0.94, 0.95, 1.04, 1.02},
96  {0, 5.5, 5.2, 4.8, 4.2},
97  {0, 6.5, 6.5, 8.5, 8.5}};
98  double MIN_C_LED[7][5] = {{0., 0., 0., 0., 0.},
99  {0., 0., 0., 0., 0.},
100  {0, 1000., 1000., 1000., 100.},
101  {0, 1.3, 1.3, 0.7, 0.3},
102  {0, 0.76, 0.76, 0.85, 0.5},
103  {0, 2.4, 2.4, 1.5, 3.5},
104  {0, 1.5, 1.5, 1.5, 3.5}};
105  double MAX_C_LED[7][5] = {{0., 0., 0., 0., 0.},
106  {0., 0., 0., 0., 0.},
107  {0, 1E20, 1E20, 1E20, 1E20},
108  {0, 1.9, 1.9, 1.65, 1.5},
109  {0, 0.94, 0.94, 0.99, 0.8},
110  {0, 3.7, 3.7, 2.7, 4.5},
111  {0, 2.5, 2.5, 2.5, 4.5}};
112  double porog_LED[5] = {0., 2., 2., 2., 2.}; // Cut for GS test in pro cents
113  double Pedest_LED[2][5] = {{0., 0.1, 0.6, 0.1, 0.8},
114  {0., 0.1, 0.1, 0.1, 0.4}}; //Cuts for Pedestal and pedestal Width
115  for (int i = 0; i <= 6; i++)
116  for (int j = 0; j <= 4; j++) {
117  MIN_M[i][j] = MIN_M_LED[i][j];
118  MAX_M[i][j] = MAX_M_LED[i][j];
119  MIN_C[i][j] = MIN_C_LED[i][j];
120  MAX_C[i][j] = MAX_C_LED[i][j];
121  }
122  for (int i = 0; i <= 4; i++) {
123  porog[i] = porog_LED[i];
124  Pedest[0][i] = Pedest_LED[0][i];
125  Pedest[1][i] = Pedest_LED[1][i];
126  }
127  }
128 
129  if (runtype == "LASER") {
130  //CUTS: [test][subdetector] ADC amplitude Am Width for Wm Ratio cut for Rm TS mean for TNm TS max for TXm
131  double MIN_M_LASER[7][5] = {{0., 0., 0., 0., 0.},
132  {0., 0., 0., 0., 0.},
133  {0, 40., 40., 100., 40.},
134  {0, 0.3, 0.9, 0.2, 0.2},
135  {0, 0.5, 0.55, 0.55, 0.60},
136  {0, 5.0, 2.5, 1.1, 5.5},
137  {0, 1.5, 1.5, 1.5, 1.5}};
138  double MAX_M_LASER[7][5] = {{0., 0., 0., 0., 0.},
139  {0., 0., 0., 0., 0.},
140  {0, 3500, 350000, 3500, 150000},
141  {0, 2.5, 3.6, 2.6, 2.1},
142  {0, 1.00, 1.00, 1.04, 1.02},
143  {0, 7.5, 6.5, 4.4, 8.5},
144  {0, 8.5, 8.5, 6.5, 8.5}};
145  double MIN_C_LASER[7][5] = {{0., 0., 0., 0., 0.},
146  {0., 0., 0., 0., 0.},
147  {0, 1000., 1000., 1000., 100.},
148  {0, 1.3, 1.3, 0.7, 0.3},
149  {0, 0.76, 0.76, 0.85, 0.5},
150  {0, 2.4, 2.4, 1.5, 3.5},
151  {0, 1.5, 1.5, 1.5, 3.5}};
152  double MAX_C_LASER[7][5] = {{0., 0., 0., 0., 0.},
153  {0., 0., 0., 0., 0.},
154  {0, 1E20, 1E20, 1E20, 1E20},
155  {0, 1.9, 1.9, 1.65, 1.5},
156  {0, 0.94, 0.94, 1.0, 0.8},
157  {0, 3.7, 3.7, 2.7, 4.5},
158  {0, 2.5, 2.5, 2.5, 4.5}};
159  double porog_LASER[5] = {0., 2., 2., 2., 2.}; // Cut for GS test in pro cents
160  // double porog_LASER[5] = {0., 200., 200., 100., 100.}; // Cut for GS test in pro cents
161  double Pedest_LASER[2][5] = {{0., 0.1, 0.6, 0.1, 0.8},
162  {0., 0.1, 0.1, 0.1, 0.4}}; //Cuts for Pedestal and pedestal Width
163  for (int i = 0; i <= 6; i++)
164  for (int j = 0; j <= 4; j++) {
165  MIN_M[i][j] = MIN_M_LASER[i][j];
166  MAX_M[i][j] = MAX_M_LASER[i][j];
167  MIN_C[i][j] = MIN_C_LASER[i][j];
168  MAX_C[i][j] = MAX_C_LASER[i][j];
169  }
170  for (int i = 0; i <= 4; i++) {
171  porog[i] = porog_LASER[i];
172  Pedest[0][i] = Pedest_LASER[0][i];
173  Pedest[1][i] = Pedest_LASER[1][i];
174  }
175  }
176  if (runtype == "PEDESTAL") {
177  //CUTS: [test][subdetector] ADC amplitude Am Width for Wm Ratio cut for Rm TS mean for TNm TS max for TXm
178  double MIN_M_PEDESTAL[7][5] = {{0., 0., 0., 0., 0.},
179  {0., 0., 0., 0., 0.},
180  {0, 10., 10., 200., 5.},
181  {0, 2.7, 2.7, 2.7, 0.2},
182  {0, 0.31, 0.31, 0.05, 0.15},
183  {0, 4.5, 4.5, 4.5, 2.0},
184  {0, 0.5, 0.5, 0.5, 0.5}};
185  double MAX_M_PEDESTAL[7][5] = {{0., 0., 0., 0., 0.},
186  {0., 0., 0., 0., 0.},
187  {0, 2500., 250000., 2500., 150000.},
188  {0, 3.0, 3.0, 5.0, 3.0},
189  {0, 0.95, 0.95, 1.00, 0.98},
190  {0, 4.6, 4.6, 4.6, 7.0},
191  {0, 9.5, 9.5, 8.5, 8.5}};
192  double MIN_C_PEDESTAL[7][5] = {{0., 0., 0., 0., 0.},
193  {0., 0., 0., 0., 0.},
194  {0, 1000., 1000., 1000., 100.},
195  {0, 1.3, 1.3, 0.7, 0.3},
196  {0, 0.76, 0.76, 0.85, 0.5},
197  {0, 2.4, 2.4, 1.5, 3.5},
198  {0, 1.5, 1.5, 1.5, 3.5}};
199  double MAX_C_PEDESTAL[7][5] = {{0., 0., 0., 0., 0.},
200  {0., 0., 0., 0., 0.},
201  {0, 1E20, 1E20, 1E20, 1E20},
202  {0, 1.9, 1.9, 1.65, 1.5},
203  {0, 0.94, 0.94, 1.0, 0.8},
204  {0, 3.7, 3.7, 2.7, 4.5},
205  {0, 2.5, 2.5, 2.5, 4.5}};
206  double porog_PEDESTAL[5] = {0., 2., 2., 2., 2.}; // Cut for GS test in pro cents
207  // double porog_PEDESTAL[5] = {0., 200., 200., 100., 100.}; // Cut for GS test in pro cents
208  double Pedest_PEDESTAL[2][5] = {{0., 0.1, 0.6, 0.1, 0.8},
209  {0., 0.1, 0.1, 0.1, 0.4}}; //Cuts for Pedestal and pedestal Width
210  for (int i = 0; i <= 6; i++)
211  for (int j = 0; j <= 4; j++) {
212  MIN_M[i][j] = MIN_M_PEDESTAL[i][j];
213  MAX_M[i][j] = MAX_M_PEDESTAL[i][j];
214  MIN_C[i][j] = MIN_C_PEDESTAL[i][j];
215  MAX_C[i][j] = MAX_C_PEDESTAL[i][j];
216  }
217  for (int i = 0; i <= 4; i++) {
218  porog[i] = porog_PEDESTAL[i];
219  Pedest[0][i] = Pedest_PEDESTAL[0][i];
220  Pedest[1][i] = Pedest_PEDESTAL[1][i];
221  }
222  }
223 
224  //======================================================================
225 
226  cout << endl;
227  cout << MIN_M[2][1] << endl;
228 
229  //======================================================================
230  // Prepare histograms and plot them to .png files
231 
232  //TCanvas *cHB = new TCanvas("cHB","cHB",1000,500);
233  TCanvas *cHB = new TCanvas("cHB", "cHB", 1000, 1000);
234  //TCanvas *cHE = new TCanvas("cHE","cHE",1500,500);
235  TCanvas *cHE = new TCanvas("cHE", "cHE", 1500, 1500);
236  //TCanvas *cONE = new TCanvas("cONE","cONE",500,500);
237  TCanvas *cONE = new TCanvas("cONE", "cONE", 1500, 500);
238  TCanvas *cPED = new TCanvas("cPED", "cPED", 1000, 500);
239  //TCanvas *cHF = new TCanvas("cHF","cHF",1000,1000);
240  TCanvas *cHF = new TCanvas("cHF", "cHF", 1000, 1000);
241 
242  // Phi-symmetry for Calibration Group:
243 
244  TCanvas *c1x0 = new TCanvas("c1x0", "c1x0", 300, 10, 800, 700);
245 
246  TCanvas *c1x1 = new TCanvas("c1x1", "c1x1", 100, 10, 600, 700);
247 
248  TCanvas *c2x1 = new TCanvas("c2x1", "c2x1", 200, 300, 1600, 800);
249 
250  TCanvas *c3x5 = new TCanvas("c3x5", "c3x5", 1000, 1500);
251  //
252 
253  char *str = (char *)alloca(10000);
254 
255  // before upgrade 2017:
256  // depth: HB depth1,2; HE depth1,2,3; HO depth4; HF depth1,2
257  // 5 depthes: 0(empty), 1,2,3,4
258 
259  // upgrade 2017:
260  // depth: HB depth1,2; HE depth1,2,3,4,5,6,7; HO depth4; HF depth1,2,3,4
261  // 8 depthes: 0(empty), 1,2,3,4,5,6,7
262 
263  // upgrade 2021:
264  // depth: HB depth1,2,3,4; HE depth1,2,3,4,5,6,7; HO depth4; HF depth1,2,3,4
265  // 10 depthes: 0(empty), 1,2,3,4,5,6,7,8,9
266 
267  // Int_t ALLDEPTH = 5;
268  // Int_t ALLDEPTH = 8;
269  Int_t ALLDEPTH = 10;
270 
271  int k_min[5] = {0, 1, 1, 4, 1}; // minimum depth for each subdet
272  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
273  // int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
274  int k_max[5] = {0, 4, 7, 4, 4}; // maximum depth for each subdet
275 
276  TH2F *Map_Ampl[33][5][ALLDEPTH]; // 2D histogramm for test,subdet,depth
277  TH2F *Map_SUB[5][ALLDEPTH]; // 2d histogramm for subdet, depth
278  TH1F *HistAmplDepth[22][5][ALLDEPTH]; // 1d histogramm for test,subdet, depth
279  TH1F *HistAmpl[22][5]; // 1d histogramm for test,subdet
280  TH2F *Map_SUBTS[5][ALLDEPTH]; // 2d histogramm for subdet, depth in different TSs
281 
282  TH1F *HistPed[3][5][4]; // 1d histogramm for test,subdet, CapID
283  TH2F *Map_Ped[3][5]; // 2d histogramm for test,subdet -> test 33
284  TH1F *hist_GoodTSshape[5]; // 1d histogramm for TS shape subdet -> test 41
285  TH1F *hist_GoodTSshape0[5]; // 1d histogramm for TS shape subdet -> test 41
286  TH1F *hist_BadTSshape[5]; // 1d histogramm for TS shape subdet -> test 41
287  TH1F *hist_BadTSshape0[5]; // 1d histogramm for TS shape subdet -> test 41
288  TH1F *hist_ADC_All[5]; // 1d histogramm for TS shape subdet -> test 42
289  TH1F *hist_ADC_DS[5][ALLDEPTH]; // 1d histogramm for TS shape subdet, depth -> test 42
290  TH1F *hist_SumADC[5][ALLDEPTH]; // 1d histogramm for TS shape subdet, depth -> test 43
291  TH1F *hist_SumADC0[5][ALLDEPTH]; // 1d histogramm for TS shape subdet, depth -> test 43
292  TH1F *hist_SumADC1[5][ALLDEPTH]; // 1d histogramm for TS shape subdet, depth -> test 43
293 
294  Map_SUB[1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1_HB");
295  Map_SUB[1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2_HB");
296  Map_SUB[2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1_HE");
297  Map_SUB[2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2_HE");
298  Map_SUB[2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3_HE");
299  Map_SUB[3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4_HO");
300  Map_SUB[4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1_HF");
301  Map_SUB[4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2_HF");
302 
303  Map_SUB[1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3_HB");
304  Map_SUB[1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4_HB");
305  Map_SUB[2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4_HE");
306  Map_SUB[2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5_HE");
307  Map_SUB[2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6_HE");
308  Map_SUB[2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7_HE");
309  Map_SUB[4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3_HF");
310  Map_SUB[4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4_HF");
311 
312  //+++++++++++++++++++++++++++++
313  //Test 0 Entries
314  //+++++++++++++++++++++++++++++
315 
316  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
317  // if (sub==1) cHB->Divide(2,1);
318  if (sub == 1)
319  cHB->Divide(2, 2);
320  // if (sub==2) cHE->Divide(3,1);
321  if (sub == 2)
322  cHE->Divide(3, 3);
323  if (sub == 3)
324  cONE->Divide(1, 1);
325  // if (sub==4) cHF->Divide(2,1);
326  if (sub == 4)
327  cHF->Divide(2, 2);
328  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
329  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
330  // int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
331  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
332  if (sub == 1)
333  cHB->cd(k);
334  if (sub == 2)
335  cHE->cd(k);
336  if (sub == 3)
337  cONE->cd(k - 3);
338  if (sub == 4)
339  cHF->cd(k);
340  gPad->SetGridy();
341  gPad->SetGridx();
342  gPad->SetLogz();
343  if (sub == 1)
344  sprintf(str, "HB, Depth%d \b", k);
345  if (sub == 2)
346  sprintf(str, "HE, Depth%d \b", k);
347  if (sub == 3)
348  sprintf(str, "HO, Depth%d \b", k);
349  if (sub == 4)
350  sprintf(str, "HF, Depth%d \b", k);
351  Map_SUB[sub][k]->SetTitle(str);
352  Map_SUB[sub][k]->SetXTitle("#eta \b");
353  Map_SUB[sub][k]->SetYTitle("#phi \b");
354  Map_SUB[sub][k]->SetZTitle("Number of events \b");
355  if (sub == 3)
356  Map_SUB[sub][k]->SetTitleOffset(0.8, "Z");
357  Map_SUB[sub][k]->Draw("COLZ");
358  Map_SUB[sub][k]->GetYaxis()->SetRangeUser(0, 72.);
359  // Map_SUB[sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
360  if (sub == 1) {
361  cHB->Modified();
362  cHB->Update();
363  }
364  if (sub == 2) {
365  cHE->Modified();
366  cHE->Update();
367  }
368  if (sub == 3) {
369  cONE->Modified();
370  cONE->Update();
371  }
372  if (sub == 4) {
373  cHF->Modified();
374  cHF->Update();
375  }
376  } //end depth
377 
378  if (sub == 1) {
379  cHB->Print("MapRateEntryHB.png");
380  cHB->Clear();
381  }
382  if (sub == 2) {
383  cHE->Print("MapRateEntryHE.png");
384  cHE->Clear();
385  }
386  if (sub == 3) {
387  cONE->Print("MapRateEntryHO.png");
388  cONE->Clear();
389  }
390  if (sub == 4) {
391  cHF->Print("MapRateEntryHF.png");
392  cHF->Clear();
393  }
394  } // end sub
395 
396  //+++++++++++++++++++++++++++++
397  //Test 1 (Cm) Rate of Cap ID errors
398  //+++++++++++++++++++++++++++++
399 
400  Map_Ampl[1][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Error_HB");
401  Map_Ampl[1][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Error_HB");
402  Map_Ampl[1][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Error_HE");
403  Map_Ampl[1][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Error_HE");
404  Map_Ampl[1][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Error_HE");
405  Map_Ampl[1][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Error_HO");
406  Map_Ampl[1][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Error_HF");
407  Map_Ampl[1][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Error_HF");
408 
409  Map_Ampl[1][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Error_HB");
410  Map_Ampl[1][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Error_HB");
411  Map_Ampl[1][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Error_HE");
412  Map_Ampl[1][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5Error_HE");
413  Map_Ampl[1][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6Error_HE");
414  Map_Ampl[1][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7Error_HE");
415  Map_Ampl[1][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Error_HF");
416  Map_Ampl[1][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Error_HF");
417 
418  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
419  // if (sub==1) cHB->Divide(2,1);
420  if (sub == 1)
421  cHB->Divide(2, 2);
422  // if (sub==2) cHE->Divide(3,1);
423  if (sub == 2)
424  cHE->Divide(3, 3);
425  if (sub == 3)
426  cONE->Divide(1, 1);
427  // if (sub==4) cHF->Divide(2,1);
428  if (sub == 4)
429  cHF->Divide(2, 2);
430  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
431  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
432  // int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
433  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
434  if (sub == 1)
435  cHB->cd(k);
436  if (sub == 2)
437  cHE->cd(k);
438  if (sub == 3)
439  cONE->cd(k - 3);
440  if (sub == 4)
441  cHF->cd(k);
442  Map_Ampl[1][sub][k]->Divide(Map_Ampl[1][sub][k], Map_SUB[sub][k], 1, 1, "B");
443  gPad->SetGridy();
444  gPad->SetGridx();
445  gPad->SetLogz();
446  if (sub == 1)
447  sprintf(str, "HB, Depth%d \b", k);
448  if (sub == 2)
449  sprintf(str, "HE, Depth%d \b", k);
450  if (sub == 3)
451  sprintf(str, "HO, Depth%d \b", k);
452  if (sub == 4)
453  sprintf(str, "HF, Depth%d \b", k);
454  Map_Ampl[1][sub][k]->SetTitle(str);
455  Map_Ampl[1][sub][k]->SetXTitle("#eta \b");
456  Map_Ampl[1][sub][k]->SetYTitle("#phi \b");
457  Map_Ampl[1][sub][k]->SetZTitle("Rate \b");
458  if (sub == 3)
459  Map_Ampl[1][sub][k]->SetTitleOffset(0.8, "Z");
460  Map_Ampl[1][sub][k]->Draw("COLZ");
461  Map_Ampl[1][sub][k]->GetYaxis()->SetRangeUser(0, 72.);
462  Map_Ampl[1][sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
463  if (sub == 1) {
464  cHB->Modified();
465  cHB->Update();
466  }
467  if (sub == 2) {
468  cHE->Modified();
469  cHE->Update();
470  }
471  if (sub == 3) {
472  cONE->Modified();
473  cONE->Update();
474  }
475  if (sub == 4) {
476  cHF->Modified();
477  cHF->Update();
478  }
479  } //end depth
480 
481  if (sub == 1) {
482  cHB->Print("MapRateCapIDHB.png");
483  cHB->Clear();
484  }
485  if (sub == 2) {
486  cHE->Print("MapRateCapIDHE.png");
487  cHE->Clear();
488  }
489  if (sub == 3) {
490  cONE->Print("MapRateCapIDHO.png");
491  cONE->Clear();
492  }
493  if (sub == 4) {
494  cHF->Print("MapRateCapIDHF.png");
495  cHF->Clear();
496  }
497  } // end sub
498 
499  //+++++++++++++++++++++++++++++
500  //Test 2 (Am) ADC amplitude
501  //+++++++++++++++++++++++++++++
502 
503  Map_Ampl[2][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1ADCAmpl225_HB");
504  Map_Ampl[2][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2ADCAmpl225_HB");
505  Map_Ampl[2][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1ADCAmpl225_HE");
506  Map_Ampl[2][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2ADCAmpl225_HE");
507  Map_Ampl[2][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3ADCAmpl225_HE");
508  Map_Ampl[2][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4ADCAmpl225_HO");
509  Map_Ampl[2][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1ADCAmpl225_HF");
510  Map_Ampl[2][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2ADCAmpl225_HF");
511 
512  Map_Ampl[2][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3ADCAmpl225_HB");
513  Map_Ampl[2][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4ADCAmpl225_HB");
514  Map_Ampl[2][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4ADCAmpl225_HE");
515  Map_Ampl[2][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5ADCAmpl225_HE");
516  Map_Ampl[2][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6ADCAmpl225_HE");
517  Map_Ampl[2][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7ADCAmpl225_HE");
518  Map_Ampl[2][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3ADCAmpl225_HF");
519  Map_Ampl[2][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4ADCAmpl225_HF");
520 
521  HistAmpl[2][1] = (TH1F *)dir->FindObjectAny("h_ADCAmpl_HB");
522  HistAmpl[2][2] = (TH1F *)dir->FindObjectAny("h_ADCAmpl_HE");
523  HistAmpl[2][3] = (TH1F *)dir->FindObjectAny("h_ADCAmpl_HO");
524  HistAmpl[2][4] = (TH1F *)dir->FindObjectAny("h_ADCAmpl_HF");
525 
526  //+++++++++++++++++++++++++++++
527  //Test 3 (Wm) Rate of RMS
528  //+++++++++++++++++++++++++++++
529 
530  Map_Ampl[3][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Amplitude225_HB");
531  Map_Ampl[3][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Amplitude225_HB");
532  Map_Ampl[3][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Amplitude225_HE");
533  Map_Ampl[3][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Amplitude225_HE");
534  Map_Ampl[3][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Amplitude225_HE");
535  Map_Ampl[3][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Amplitude225_HO");
536  Map_Ampl[3][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Amplitude225_HF");
537  Map_Ampl[3][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Amplitude225_HF");
538 
539  Map_Ampl[3][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Amplitude225_HB");
540  Map_Ampl[3][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Amplitude225_HB");
541  Map_Ampl[3][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Amplitude225_HE");
542  Map_Ampl[3][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5Amplitude225_HE");
543  Map_Ampl[3][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6Amplitude225_HE");
544  Map_Ampl[3][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7Amplitude225_HE");
545  Map_Ampl[3][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Amplitude225_HF");
546  Map_Ampl[3][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Amplitude225_HF");
547 
548  HistAmpl[3][1] = (TH1F *)dir->FindObjectAny("h_Amplitude_HB");
549  HistAmpl[3][2] = (TH1F *)dir->FindObjectAny("h_Amplitude_HE");
550  HistAmpl[3][3] = (TH1F *)dir->FindObjectAny("h_Amplitude_HO");
551  HistAmpl[3][4] = (TH1F *)dir->FindObjectAny("h_Amplitude_HF");
552 
553  //+++++++++++++++++++++++++++++
554  //Test 4 (Rm) Rate of ratio 4 near max TS/ All TS
555  //+++++++++++++++++++++++++++++
556 
557  Map_Ampl[4][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Ampl047_HB");
558  Map_Ampl[4][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Ampl047_HB");
559  Map_Ampl[4][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Ampl047_HE");
560  Map_Ampl[4][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Ampl047_HE");
561  Map_Ampl[4][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Ampl047_HE");
562  Map_Ampl[4][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Ampl047_HO");
563  Map_Ampl[4][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Ampl047_HF");
564  Map_Ampl[4][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Ampl047_HF");
565 
566  Map_Ampl[4][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Ampl047_HB");
567  Map_Ampl[4][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Ampl047_HB");
568  Map_Ampl[4][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Ampl047_HE");
569  Map_Ampl[4][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5Ampl047_HE");
570  Map_Ampl[4][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6Ampl047_HE");
571  Map_Ampl[4][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7Ampl047_HE");
572  Map_Ampl[4][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Ampl047_HF");
573  Map_Ampl[4][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Ampl047_HF");
574 
575  HistAmpl[4][1] = (TH1F *)dir->FindObjectAny("h_Ampl_HB");
576  HistAmpl[4][2] = (TH1F *)dir->FindObjectAny("h_Ampl_HE");
577  HistAmpl[4][3] = (TH1F *)dir->FindObjectAny("h_Ampl_HO");
578  HistAmpl[4][4] = (TH1F *)dir->FindObjectAny("h_Ampl_HF");
579 
580  //+++++++++++++++++++++++++++++
581  //Test 5 (TNm) Mean position in 1-8 TS range
582  //+++++++++++++++++++++++++++++
583 
584  Map_Ampl[5][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TSmeanA225_HB");
585  Map_Ampl[5][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TSmeanA225_HB");
586  Map_Ampl[5][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TSmeanA225_HE");
587  Map_Ampl[5][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TSmeanA225_HE");
588  Map_Ampl[5][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TSmeanA225_HE");
589  Map_Ampl[5][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmeanA225_HO");
590  Map_Ampl[5][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TSmeanA225_HF");
591  Map_Ampl[5][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TSmeanA225_HF");
592 
593  Map_Ampl[5][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TSmeanA225_HB");
594  Map_Ampl[5][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmeanA225_HB");
595  Map_Ampl[5][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmeanA225_HE");
596  Map_Ampl[5][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5TSmeanA225_HE");
597  Map_Ampl[5][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6TSmeanA225_HE");
598  Map_Ampl[5][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7TSmeanA225_HE");
599  Map_Ampl[5][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TSmeanA225_HF");
600  Map_Ampl[5][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmeanA225_HF");
601 
602  HistAmpl[5][1] = (TH1F *)dir->FindObjectAny("h_TSmeanA_HB");
603  HistAmpl[5][2] = (TH1F *)dir->FindObjectAny("h_TSmeanA_HE");
604  HistAmpl[5][3] = (TH1F *)dir->FindObjectAny("h_TSmeanA_HO");
605  HistAmpl[5][4] = (TH1F *)dir->FindObjectAny("h_TSmeanA_HF");
606 
607  //+++++++++++++++++++++++++++++
608  //Test 6 (TXm) Maximum position in 1-8 TS range
609  //+++++++++++++++++++++++++++++
610 
611  Map_Ampl[6][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TSmaxA225_HB");
612  Map_Ampl[6][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TSmaxA225_HB");
613  Map_Ampl[6][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TSmaxA225_HE");
614  Map_Ampl[6][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TSmaxA225_HE");
615  Map_Ampl[6][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TSmaxA225_HE");
616  Map_Ampl[6][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmaxA225_HO");
617  Map_Ampl[6][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TSmaxA225_HF");
618  Map_Ampl[6][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TSmaxA225_HF");
619 
620  Map_Ampl[6][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TSmaxA225_HB");
621  Map_Ampl[6][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmaxA225_HB");
622  Map_Ampl[6][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmaxA225_HE");
623  Map_Ampl[6][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5TSmaxA225_HE");
624  Map_Ampl[6][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6TSmaxA225_HE");
625  Map_Ampl[6][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7TSmaxA225_HE");
626  Map_Ampl[6][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TSmaxA225_HF");
627  Map_Ampl[6][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmaxA225_HF");
628 
629  HistAmpl[6][1] = (TH1F *)dir->FindObjectAny("h_TSmaxA_HB");
630  HistAmpl[6][2] = (TH1F *)dir->FindObjectAny("h_TSmaxA_HE");
631  HistAmpl[6][3] = (TH1F *)dir->FindObjectAny("h_TSmaxA_HO");
632  HistAmpl[6][4] = (TH1F *)dir->FindObjectAny("h_TSmaxA_HF");
633 
634  for (int test = 2; test <= 6; test++) { //Test: 2-Am, 3-Wm, 4-Rm, 5-TNm, 6-TXm,
635  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
636  // if (sub==1) cHB->Divide(2,1);
637  if (sub == 1)
638  cHB->Divide(2, 2);
639  // if (sub==2) cHE->Divide(3,1);
640  if (sub == 2)
641  cHE->Divide(3, 3);
642  if (sub == 3)
643  cONE->Divide(1, 1);
644  // if (sub==4) cHF->Divide(2,1);
645  if (sub == 4)
646  cHF->Divide(2, 2);
647  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
648  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
649  // int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
650  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
651  if (sub == 1)
652  cHB->cd(k);
653  if (sub == 2)
654  cHE->cd(k);
655  if (sub == 3)
656  cONE->cd(k - 3);
657  if (sub == 4)
658  cHF->cd(k);
659  Map_Ampl[test][sub][k]->Divide(Map_Ampl[test][sub][k], Map_SUB[sub][k], 1, 1, "B");
660  gPad->SetGridy();
661  gPad->SetGridx();
662  gPad->SetLogz();
663  if (sub == 1)
664  sprintf(str, "HB, Depth%d \b", k);
665  if (sub == 2)
666  sprintf(str, "HE, Depth%d \b", k);
667  if (sub == 3)
668  sprintf(str, "HO, Depth%d \b", k);
669  if (sub == 4)
670  sprintf(str, "HF, Depth%d \b", k);
671  Map_Ampl[test][sub][k]->SetTitle(str);
672  Map_Ampl[test][sub][k]->SetXTitle("#eta \b");
673  Map_Ampl[test][sub][k]->SetYTitle("#phi \b");
674  Map_Ampl[test][sub][k]->SetZTitle("Rate \b");
675  if (sub == 3)
676  Map_Ampl[test][sub][k]->SetTitleOffset(0.8, "Z");
677  Map_Ampl[test][sub][k]->Draw("COLZ");
678  Map_Ampl[test][sub][k]->GetYaxis()->SetRangeUser(0, 72.);
679  Map_Ampl[test][sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
680  if (sub == 1) {
681  cHB->Modified();
682  cHB->Update();
683  }
684  if (sub == 2) {
685  cHE->Modified();
686  cHE->Update();
687  }
688  if (sub == 3) {
689  cONE->Modified();
690  cONE->Update();
691  }
692  if (sub == 4) {
693  cHF->Modified();
694  cHF->Update();
695  }
696  } //end depth
697  if (test == 2) {
698  if (sub == 1) {
699  cHB->Print("MapRateAmplHB.png");
700  cHB->Clear();
701  }
702  if (sub == 2) {
703  cHE->Print("MapRateAmplHE.png");
704  cHE->Clear();
705  }
706  if (sub == 3) {
707  cONE->Print("MapRateAmplHO.png");
708  cONE->Clear();
709  }
710  if (sub == 4) {
711  cHF->Print("MapRateAmplHF.png");
712  cHF->Clear();
713  }
714  }
715  if (test == 3) {
716  if (sub == 1) {
717  cHB->Print("MapRateRMSHB.png");
718  cHB->Clear();
719  }
720  if (sub == 2) {
721  cHE->Print("MapRateRMSHE.png");
722  cHE->Clear();
723  }
724  if (sub == 3) {
725  cONE->Print("MapRateRMSHO.png");
726  cONE->Clear();
727  }
728  if (sub == 4) {
729  cHF->Print("MapRateRMSHF.png");
730  cHF->Clear();
731  }
732  }
733  if (test == 4) {
734  if (sub == 1) {
735  cHB->Print("MapRate43TStoAllTSHB.png");
736  cHB->Clear();
737  }
738  if (sub == 2) {
739  cHE->Print("MapRate43TStoAllTSHE.png");
740  cHE->Clear();
741  }
742  if (sub == 3) {
743  cONE->Print("MapRate43TStoAllTSHO.png");
744  cONE->Clear();
745  }
746  if (sub == 4) {
747  cHF->Print("MapRate43TStoAllTSHF.png");
748  cHF->Clear();
749  }
750  }
751  if (test == 5) {
752  if (sub == 1) {
753  cHB->Print("MapRateMeanPosHB.png");
754  cHB->Clear();
755  }
756  if (sub == 2) {
757  cHE->Print("MapRateMeanPosHE.png");
758  cHE->Clear();
759  }
760  if (sub == 3) {
761  cONE->Print("MapRateMeanPosHO.png");
762  cONE->Clear();
763  }
764  if (sub == 4) {
765  cHF->Print("MapRateMeanPosHF.png");
766  cHF->Clear();
767  }
768  }
769  if (test == 6) {
770  if (sub == 1) {
771  cHB->Print("MapRateMaxPosHB.png");
772  cHB->Clear();
773  }
774  if (sub == 2) {
775  cHE->Print("MapRateMaxPosHE.png");
776  cHE->Clear();
777  }
778  if (sub == 3) {
779  cONE->Print("MapRateMaxPosHO.png");
780  cONE->Clear();
781  }
782  if (sub == 4) {
783  cHF->Print("MapRateMaxPosHF.png");
784  cHF->Clear();
785  }
786  }
787 
788  // cONE->Divide(1,1);
789  cONE->Divide(3, 1);
790  if (test == 2 && sub == 2) {
791  cONE->cd(2);
792  TH1F *kjkjkhj2 = (TH1F *)dir->FindObjectAny("h_AmplitudeHEtest1");
793  kjkjkhj2->Draw("");
794  kjkjkhj2->SetTitle("HE, All Depth: shunt1");
795  cONE->cd(3);
796  TH1F *kjkjkhj3 = (TH1F *)dir->FindObjectAny("h_AmplitudeHEtest6");
797  kjkjkhj3->Draw("");
798  kjkjkhj3->SetTitle("HE, All Depth: shunt6");
799  }
800  if (test == 2 && sub == 1) {
801  cONE->cd(2);
802  TH1F *kjkjkhb2 = (TH1F *)dir->FindObjectAny("h_AmplitudeHBtest1");
803  kjkjkhb2->Draw("");
804  kjkjkhb2->SetTitle("HB, All Depth: shunt1");
805  cONE->cd(3);
806  TH1F *kjkjkhb3 = (TH1F *)dir->FindObjectAny("h_AmplitudeHBtest6");
807  kjkjkhb3->Draw("");
808  kjkjkhb3->SetTitle("HB, All Depth: shunt6");
809  }
810  cONE->cd(1);
811  gPad->SetGridy();
812  gPad->SetGridx();
813  gPad->SetLogy();
814  if (sub == 1)
815  HistAmpl[test][sub]->SetTitle("HB, All Depth: shunt6");
816  if (sub == 2)
817  HistAmpl[test][sub]->SetTitle("HE, All Depth: shunt6");
818  if (sub == 3)
819  HistAmpl[test][sub]->SetTitle("HO, All Depth");
820  if (sub == 4)
821  HistAmpl[test][sub]->SetTitle("HF, All Depth");
822  if (test == 2)
823  HistAmpl[test][sub]->SetXTitle("ADC Amlitude in each event & cell \b");
824  if (test == 3)
825  HistAmpl[test][sub]->SetXTitle("RMS in each event & cell \b");
826  if (test == 4)
827  HistAmpl[test][sub]->SetXTitle("Ratio in each event & cell \b");
828  if (test == 5)
829  HistAmpl[test][sub]->SetXTitle("Mean TS position in each event & cell \b");
830  if (test == 6)
831  HistAmpl[test][sub]->SetXTitle("Max TS position in each event & cell \b");
832  HistAmpl[test][sub]->SetYTitle("Number of cell-events \b");
833  HistAmpl[test][sub]->SetLineColor(4);
834  HistAmpl[test][sub]->SetLineWidth(2);
835  HistAmpl[test][sub]->SetTitleOffset(1.4, "Y");
836  HistAmpl[test][sub]->Draw("");
837  // // HistAmpl[test][sub]->GetYaxis()->SetRangeUser(1., 100.);
838  // if (test==2) {gPad->SetLogx(); HistAmpl[test][sub]->GetXaxis()->SetRangeUser(1., 10000.);}
839  if (test == 2) {
840  gPad->SetLogx();
841  }
842  if (test == 3)
843  HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 5.); // width
844  if (test == 4)
845  HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 1.); // R
846  if (test == 5)
847  HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 9.); //Tn
848  if (test == 6)
849  HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 9.); //Tx
850  cONE->Modified();
851  cONE->Update();
852  double min_x[] = {MIN_M[test][sub], MIN_M[test][sub]};
853  double min_y[] = {0., 100000000.};
854  TGraph *MIN = new TGraph(2, min_x, min_y);
855  MIN->SetLineStyle(2);
856  MIN->SetLineColor(2);
857  MIN->SetLineWidth(2 + 100 * 100);
858  MIN->SetFillStyle(3005);
859  MIN->SetFillColor(2);
860  MIN->Draw("L");
861  double max_x[] = {MAX_M[test][sub], MAX_M[test][sub]};
862  double max_y[] = {0., 100000000.};
863  TGraph *MAX = new TGraph(2, max_x, max_y);
864  MAX->SetLineStyle(2);
865  MAX->SetLineColor(2);
866  MAX->SetLineWidth(-2 - 100 * 100);
867  MAX->SetFillStyle(3004);
868  MAX->SetFillColor(2);
869  MAX->Draw("L");
870  if (test == 2) {
871  if (sub == 1) {
872  cONE->Print("HistAmplHB.png");
873  cONE->Clear();
874  }
875  if (sub == 2) {
876  cONE->Print("HistAmplHE.png");
877  cONE->Clear();
878  }
879  if (sub == 3) {
880  cONE->Print("HistAmplHO.png");
881  cONE->Clear();
882  }
883  if (sub == 4) {
884  cONE->Print("HistAmplHF.png");
885  cONE->Clear();
886  }
887  }
888  if (test == 3) {
889  if (sub == 1) {
890  cONE->Print("HistRMSHB.png");
891  cONE->Clear();
892  }
893  if (sub == 2) {
894  cONE->Print("HistRMSHE.png");
895  cONE->Clear();
896  }
897  if (sub == 3) {
898  cONE->Print("HistRMSHO.png");
899  cONE->Clear();
900  }
901  if (sub == 4) {
902  cONE->Print("HistRMSHF.png");
903  cONE->Clear();
904  }
905  }
906  if (test == 4) {
907  if (sub == 1) {
908  cONE->Print("Hist43TStoAllTSHB.png");
909  cONE->Clear();
910  }
911  if (sub == 2) {
912  cONE->Print("Hist43TStoAllTSHE.png");
913  cONE->Clear();
914  }
915  if (sub == 3) {
916  cONE->Print("Hist43TStoAllTSHO.png");
917  cONE->Clear();
918  }
919  if (sub == 4) {
920  cONE->Print("Hist43TStoAllTSHF.png");
921  cONE->Clear();
922  }
923  }
924  if (test == 5) {
925  if (sub == 1) {
926  cONE->Print("HistMeanPosHB.png");
927  cONE->Clear();
928  }
929  if (sub == 2) {
930  cONE->Print("HistMeanPosHE.png");
931  cONE->Clear();
932  }
933  if (sub == 3) {
934  cONE->Print("HistMeanPosHO.png");
935  cONE->Clear();
936  }
937  if (sub == 4) {
938  cONE->Print("HistMeanPosHF.png");
939  cONE->Clear();
940  }
941  }
942  if (test == 6) {
943  if (sub == 1) {
944  cONE->Print("HistMaxPosHB.png");
945  cONE->Clear();
946  }
947  if (sub == 2) {
948  cONE->Print("HistMaxPosHE.png");
949  cONE->Clear();
950  }
951  if (sub == 3) {
952  cONE->Print("HistMaxPosHO.png");
953  cONE->Clear();
954  }
955  if (sub == 4) {
956  cONE->Print("HistMaxPosHF.png");
957  cONE->Clear();
958  }
959  }
960  } // end sub
961  } //end test
962 
963  TH2F *Map_Calib[5][5]; // 2d histogramm for subdet, depth
964 
965  Map_Calib[1][1] = (TH2F *)dir->FindObjectAny("h_map_HB");
966  Map_Calib[1][2] = (TH2F *)dir->FindObjectAny("h_map_HB");
967  Map_Calib[2][1] = (TH2F *)dir->FindObjectAny("h_map_HE");
968  Map_Calib[2][2] = (TH2F *)dir->FindObjectAny("h_map_HE");
969  Map_Calib[2][3] = (TH2F *)dir->FindObjectAny("h_map_HE");
970  Map_Calib[3][4] = (TH2F *)dir->FindObjectAny("h_map_HO");
971  Map_Calib[4][1] = (TH2F *)dir->FindObjectAny("h_map_HF");
972  Map_Calib[4][2] = (TH2F *)dir->FindObjectAny("h_map_HF");
973 
974  //+++++++++++++++++++++++++++++
975  //Test 0 Entries
976  //+++++++++++++++++++++++++++++
977 
978  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
979  // if (sub==1) cHB->Divide(2,1);
980  // if (sub==2) cHE->Divide(3,1);
981  cONE->Divide(1, 1);
982  // if (sub==4) cHB->Divide(2,1);
983  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
984  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
985  // for (int k=k_min[sub];k<=k_max[sub];k++) { //Depth
986  int k = 1;
987  cONE->cd(k);
988  // if (sub==1) cHB->cd(k);
989  // if (sub==2) cHE->cd(k);
990  if (sub == 3)
991  k = 4;
992  // if (sub==4) cHB->cd(k);
993  gPad->SetGridy();
994  gPad->SetGridx();
995  gPad->SetLogz();
996  if (sub == 1)
997  sprintf(str, "HB");
998  if (sub == 2)
999  sprintf(str, "HE");
1000  if (sub == 3)
1001  sprintf(str, "HO");
1002  if (sub == 4)
1003  sprintf(str, "HF");
1004  Map_Calib[sub][k]->SetTitle(str);
1005  Map_Calib[sub][k]->SetXTitle("#eta \b");
1006  Map_Calib[sub][k]->SetYTitle("#phi \b");
1007  Map_Calib[sub][k]->SetZTitle("Number of events\b");
1008  if (sub == 3)
1009  Map_Calib[sub][k]->SetTitleOffset(0.8, "Z");
1010  Map_Calib[sub][k]->Draw("COLZ");
1011  Map_Calib[sub][k]->GetYaxis()->SetRangeUser(0, 72.);
1012  // Map_Calib[sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
1013  // if (sub==1) {cHB->Modified(); cHB->Update();}
1014  // if (sub==2) {cHE->Modified(); cHE->Update();}
1015  cONE->Modified();
1016  cONE->Update();
1017  // if (sub==4) {cHB->Modified(); cHB->Update();}
1018  // }//end depth
1019 
1020  if (sub == 1) {
1021  cONE->Print("MapRateCalibEntryHB.png");
1022  cONE->Clear();
1023  }
1024  if (sub == 2) {
1025  cONE->Print("MapRateCalibEntryHE.png");
1026  cONE->Clear();
1027  }
1028  if (sub == 3) {
1029  cONE->Print("MapRateCalibEntryHO.png");
1030  cONE->Clear();
1031  }
1032  if (sub == 4) {
1033  cONE->Print("MapRateCalibEntryHF.png");
1034  cONE->Clear();
1035  }
1036  } // end sub
1037 
1038  //+++++++++++++++++++++++++++++
1039  //Test 11 (Cc) Rate of Cap ID errors for calibration channels
1040  //+++++++++++++++++++++++++++++
1041 
1042  Map_Ampl[11][1][1] = (TH2F *)dir->FindObjectAny("h_mapCapCalib047_HB");
1043  Map_Ampl[11][1][2] = (TH2F *)dir->FindObjectAny("h_mapCapCalib047_HB");
1044  Map_Ampl[11][2][1] = (TH2F *)dir->FindObjectAny("h_mapCapCalib047_HE");
1045  Map_Ampl[11][2][2] = (TH2F *)dir->FindObjectAny("h_mapCapCalib047_HE");
1046  Map_Ampl[11][2][3] = (TH2F *)dir->FindObjectAny("h_mapCapCalib047_HE");
1047  Map_Ampl[11][3][4] = (TH2F *)dir->FindObjectAny("h_mapCapCalib047_HO");
1048  Map_Ampl[11][4][1] = (TH2F *)dir->FindObjectAny("h_mapCapCalib047_HF");
1049  Map_Ampl[11][4][2] = (TH2F *)dir->FindObjectAny("h_mapCapCalib047_HF");
1050 
1051  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
1052  // if (sub==1) cHB->Divide(2,1);
1053  // if (sub==2) cHE->Divide(3,1);
1054  cONE->Divide(1, 1);
1055  // if (sub==4) cHB->Divide(2,1);
1056  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
1057  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
1058  // for (int k=k_min[sub];k<=k_max[sub];k++) { //Depth
1059  int k = 1;
1060  cONE->cd(k);
1061  // if (sub==1) cHB->cd(k);
1062  // if (sub==2) cHE->cd(k);
1063  if (sub == 3)
1064  k = 4;
1065  // if (sub==4) cHB->cd(k);
1066  Map_Ampl[11][sub][k]->Divide(Map_Ampl[11][sub][k], Map_Calib[sub][k], 1, 1, "B");
1067  gPad->SetGridy();
1068  gPad->SetGridx();
1069  gPad->SetLogz();
1070  if (sub == 1)
1071  sprintf(str, "HB");
1072  if (sub == 2)
1073  sprintf(str, "HE");
1074  if (sub == 3)
1075  sprintf(str, "HO");
1076  if (sub == 4)
1077  sprintf(str, "HF");
1078  Map_Ampl[11][sub][k]->SetTitle(str);
1079  Map_Ampl[11][sub][k]->SetXTitle("#eta \b");
1080  Map_Ampl[11][sub][k]->SetYTitle("#phi \b");
1081  Map_Ampl[11][sub][k]->SetZTitle("Rate \b");
1082  Map_Ampl[11][sub][k]->SetTitleOffset(0.75, "Z");
1083  Map_Ampl[11][sub][k]->Draw("COLZ");
1084  Map_Ampl[11][sub][k]->GetYaxis()->SetRangeUser(0, 72.);
1085  Map_Ampl[11][sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
1086  // if (sub==1) {cHB->Modified(); cHB->Update();}
1087  // if (sub==2) {cHE->Modified(); cHE->Update();}
1088  cONE->Modified();
1089  cONE->Update();
1090  // if (sub==4) {cHB->Modified(); cHB->Update();}
1091  // }//end depth
1092 
1093  if (sub == 1) {
1094  cONE->Print("MapRateCapCalibHB.png");
1095  cONE->Clear();
1096  }
1097  if (sub == 2) {
1098  cONE->Print("MapRateCapCalibHE.png");
1099  cONE->Clear();
1100  }
1101  if (sub == 3) {
1102  cONE->Print("MapRateCapCalibHO.png");
1103  cONE->Clear();
1104  }
1105  if (sub == 4) {
1106  cONE->Print("MapRateCapCalibHF.png");
1107  cONE->Clear();
1108  }
1109  } // end sub
1110 
1111  //+++++++++++++++++++++++++++++
1112  //Test 12 (Ac) ADC amplitude for calibration chanels
1113  //+++++++++++++++++++++++++++++
1114 
1115  Map_Ampl[12][1][1] = (TH2F *)dir->FindObjectAny("h_mapADCCalib047_HB");
1116  Map_Ampl[12][1][2] = (TH2F *)dir->FindObjectAny("h_mapADCCalib047_HB");
1117  Map_Ampl[12][2][1] = (TH2F *)dir->FindObjectAny("h_mapADCCalib047_HE");
1118  Map_Ampl[12][2][2] = (TH2F *)dir->FindObjectAny("h_mapADCCalib047_HE");
1119  Map_Ampl[12][2][3] = (TH2F *)dir->FindObjectAny("h_mapADCCalib047_HE");
1120  Map_Ampl[12][3][4] = (TH2F *)dir->FindObjectAny("h_mapADCCalib047_HO");
1121  Map_Ampl[12][4][1] = (TH2F *)dir->FindObjectAny("h_mapADCCalib047_HF");
1122  Map_Ampl[12][4][2] = (TH2F *)dir->FindObjectAny("h_mapADCCalib047_HF");
1123 
1124  HistAmpl[12][1] = (TH1F *)dir->FindObjectAny("h_ADCCalib_HB");
1125  HistAmpl[12][2] = (TH1F *)dir->FindObjectAny("h_ADCCalib_HE");
1126  HistAmpl[12][3] = (TH1F *)dir->FindObjectAny("h_ADCCalib_HO");
1127  HistAmpl[12][4] = (TH1F *)dir->FindObjectAny("h_ADCCalib_HF");
1128 
1129  //+++++++++++++++++++++++++++++
1130  //Test 13 (Wc) Rate of RMS
1131  //+++++++++++++++++++++++++++++
1132 
1133  Map_Ampl[13][1][1] = (TH2F *)dir->FindObjectAny("h_mapWidthCalib047_HB");
1134  Map_Ampl[13][1][2] = (TH2F *)dir->FindObjectAny("h_mapWidthCalib047_HB");
1135  Map_Ampl[13][2][1] = (TH2F *)dir->FindObjectAny("h_mapWidthCalib047_HE");
1136  Map_Ampl[13][2][2] = (TH2F *)dir->FindObjectAny("h_mapWidthCalib047_HE");
1137  Map_Ampl[13][2][3] = (TH2F *)dir->FindObjectAny("h_mapWidthCalib047_HE");
1138  Map_Ampl[13][3][4] = (TH2F *)dir->FindObjectAny("h_mapWidthCalib047_HO");
1139  Map_Ampl[13][4][1] = (TH2F *)dir->FindObjectAny("h_mapWidthCalib047_HF");
1140  Map_Ampl[13][4][2] = (TH2F *)dir->FindObjectAny("h_mapWidthCalib047_HF");
1141 
1142  HistAmpl[13][1] = (TH1F *)dir->FindObjectAny("h_WidthCalib_HB");
1143  HistAmpl[13][2] = (TH1F *)dir->FindObjectAny("h_WidthCalib_HE");
1144  HistAmpl[13][3] = (TH1F *)dir->FindObjectAny("h_WidthCalib_HO");
1145  HistAmpl[13][4] = (TH1F *)dir->FindObjectAny("h_WidthCalib_HF");
1146 
1147  //+++++++++++++++++++++++++++++
1148  //Test 14 (Rc) Rate of ratio 4 near max TS/ All TS
1149  //+++++++++++++++++++++++++++++
1150 
1151  Map_Ampl[14][1][1] = (TH2F *)dir->FindObjectAny("h_mapRatioCalib047_HB");
1152  Map_Ampl[14][1][2] = (TH2F *)dir->FindObjectAny("h_mapRatioCalib047_HB");
1153  Map_Ampl[14][2][1] = (TH2F *)dir->FindObjectAny("h_mapRatioCalib047_HE");
1154  Map_Ampl[14][2][2] = (TH2F *)dir->FindObjectAny("h_mapRatioCalib047_HE");
1155  Map_Ampl[14][2][3] = (TH2F *)dir->FindObjectAny("h_mapRatioCalib047_HE");
1156  Map_Ampl[14][3][4] = (TH2F *)dir->FindObjectAny("h_mapRatioCalib047_HO");
1157  Map_Ampl[14][4][1] = (TH2F *)dir->FindObjectAny("h_mapRatioCalib047_HF");
1158  Map_Ampl[14][4][2] = (TH2F *)dir->FindObjectAny("h_mapRatioCalib047_HF");
1159 
1160  HistAmpl[14][1] = (TH1F *)dir->FindObjectAny("h_RatioCalib_HB");
1161  HistAmpl[14][2] = (TH1F *)dir->FindObjectAny("h_RatioCalib_HE");
1162  HistAmpl[14][3] = (TH1F *)dir->FindObjectAny("h_RatioCalib_HO");
1163  HistAmpl[14][4] = (TH1F *)dir->FindObjectAny("h_RatioCalib_HF");
1164 
1165  //+++++++++++++++++++++++++++++
1166  //Test 15 (TNc) Mean position in 1-8 TS range
1167  //+++++++++++++++++++++++++++++
1168 
1169  Map_Ampl[15][1][1] = (TH2F *)dir->FindObjectAny("h_mapTSmeanCalib047_HB");
1170  Map_Ampl[15][1][2] = (TH2F *)dir->FindObjectAny("h_mapTSmeanCalib047_HB");
1171  Map_Ampl[15][2][1] = (TH2F *)dir->FindObjectAny("h_mapTSmeanCalib047_HE");
1172  Map_Ampl[15][2][2] = (TH2F *)dir->FindObjectAny("h_mapTSmeanCalib047_HE");
1173  Map_Ampl[15][2][3] = (TH2F *)dir->FindObjectAny("h_mapTSmeanCalib047_HE");
1174  Map_Ampl[15][3][4] = (TH2F *)dir->FindObjectAny("h_mapTSmeanCalib047_HO");
1175  Map_Ampl[15][4][1] = (TH2F *)dir->FindObjectAny("h_mapTSmeanCalib047_HF");
1176  Map_Ampl[15][4][2] = (TH2F *)dir->FindObjectAny("h_mapTSmeanCalib047_HF");
1177 
1178  HistAmpl[15][1] = (TH1F *)dir->FindObjectAny("h_TSmeanCalib_HB");
1179  HistAmpl[15][2] = (TH1F *)dir->FindObjectAny("h_TSmeanCalib_HE");
1180  HistAmpl[15][3] = (TH1F *)dir->FindObjectAny("h_TSmeanCalib_HO");
1181  HistAmpl[15][4] = (TH1F *)dir->FindObjectAny("h_TSmeanCalib_HF");
1182 
1183  //+++++++++++++++++++++++++++++
1184  //Test 16 (TXc) Maximum position in 1-8 TS range
1185  //+++++++++++++++++++++++++++++
1186 
1187  Map_Ampl[16][1][1] = (TH2F *)dir->FindObjectAny("h_mapTSmaxCalib047_HB");
1188  Map_Ampl[16][1][2] = (TH2F *)dir->FindObjectAny("h_mapTSmaxCalib047_HB");
1189  Map_Ampl[16][2][1] = (TH2F *)dir->FindObjectAny("h_mapTSmaxCalib047_HE");
1190  Map_Ampl[16][2][2] = (TH2F *)dir->FindObjectAny("h_mapTSmaxCalib047_HE");
1191  Map_Ampl[16][2][3] = (TH2F *)dir->FindObjectAny("h_mapTSmaxCalib047_HE");
1192  Map_Ampl[16][3][4] = (TH2F *)dir->FindObjectAny("h_mapTSmaxCalib047_HO");
1193  Map_Ampl[16][4][1] = (TH2F *)dir->FindObjectAny("h_mapTSmaxCalib047_HF");
1194  Map_Ampl[16][4][2] = (TH2F *)dir->FindObjectAny("h_mapTSmaxCalib047_HF");
1195 
1196  HistAmpl[16][1] = (TH1F *)dir->FindObjectAny("h_TSmaxCalib_HB");
1197  HistAmpl[16][2] = (TH1F *)dir->FindObjectAny("h_TSmaxCalib_HE");
1198  HistAmpl[16][3] = (TH1F *)dir->FindObjectAny("h_TSmaxCalib_HO");
1199  HistAmpl[16][4] = (TH1F *)dir->FindObjectAny("h_TSmaxCalib_HF");
1200 
1201  for (int test = 12; test <= 16; test++) { //Test: 2-Am, 3-Wm, 4-Rm, 5-TNm, 6-TXm,
1202  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
1203  if (sub == 1)
1204  cONE->Divide(1, 1); //cHB->Divide(2,1);
1205  if (sub == 2)
1206  cONE->Divide(1, 1); //cHE->Divide(3,1);
1207  if (sub == 3)
1208  cONE->Divide(1, 1);
1209  if (sub == 4)
1210  cONE->Divide(1, 1); //cHB->Divide(2,1);
1211  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
1212  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
1213  // for (int k=k_min[sub];k<=k_max[sub];k++) { //Depth
1214  int k = 1;
1215  if (sub == 1) {
1216  k = 1;
1217  cONE->cd(k);
1218  } //cHB->cd(k); }
1219  if (sub == 2) {
1220  k = 1;
1221  cONE->cd(k);
1222  } //cHE->cd(k); }
1223  if (sub == 3) {
1224  k = 4;
1225  cONE->cd(k - 3);
1226  }
1227  if (sub == 4) {
1228  k = 1;
1229  cONE->cd(k);
1230  } //cHB->cd(k); }
1231  Map_Ampl[test][sub][k]->Divide(Map_Ampl[test][sub][k], Map_Calib[sub][k], 1, 1, "B");
1232  gPad->SetGridy();
1233  gPad->SetGridx();
1234  gPad->SetLogz();
1235  if (sub == 1)
1236  sprintf(str, "HB");
1237  if (sub == 2)
1238  sprintf(str, "HE");
1239  if (sub == 3)
1240  sprintf(str, "HO");
1241  if (sub == 4)
1242  sprintf(str, "HF");
1243  Map_Ampl[test][sub][k]->SetTitle(str);
1244  Map_Ampl[test][sub][k]->SetXTitle("#eta \b");
1245  Map_Ampl[test][sub][k]->SetYTitle("#phi \b");
1246  Map_Ampl[test][sub][k]->SetZTitle("Rate \b");
1247  Map_Ampl[test][sub][k]->SetTitleOffset(0.8, "Z");
1248  Map_Ampl[test][sub][k]->Draw("COLZ");
1249  Map_Ampl[test][sub][k]->GetYaxis()->SetRangeUser(0, 72.);
1250  Map_Ampl[test][sub][k]->GetZaxis()->SetRangeUser(0.00001, 1.);
1251  // if (sub==1) {cHB->Modified(); cHB->Update();}
1252  // if (sub==2) {cHE->Modified(); cHE->Update();}
1253  cONE->Modified();
1254  cONE->Update();
1255  // if (sub==4) {cHB->Modified(); cHB->Update();}
1256  // }//end depth
1257  if (test == 12) {
1258  if (sub == 1) {
1259  cONE->Print("MapRateAmplCalibHB.png");
1260  cONE->Clear();
1261  }
1262  if (sub == 2) {
1263  cONE->Print("MapRateAmplCalibHE.png");
1264  cONE->Clear();
1265  }
1266  if (sub == 3) {
1267  cONE->Print("MapRateAmplCalibHO.png");
1268  cONE->Clear();
1269  }
1270  if (sub == 4) {
1271  cONE->Print("MapRateAmplCalibHF.png");
1272  cONE->Clear();
1273  }
1274  }
1275  if (test == 13) {
1276  if (sub == 1) {
1277  cONE->Print("MapRateRMSCalibHB.png");
1278  cONE->Clear();
1279  }
1280  if (sub == 2) {
1281  cONE->Print("MapRateRMSCalibHE.png");
1282  cONE->Clear();
1283  }
1284  if (sub == 3) {
1285  cONE->Print("MapRateRMSCalibHO.png");
1286  cONE->Clear();
1287  }
1288  if (sub == 4) {
1289  cONE->Print("MapRateRMSCalibHF.png");
1290  cONE->Clear();
1291  }
1292  }
1293  if (test == 14) {
1294  if (sub == 1) {
1295  cONE->Print("MapRate43TStoAllTSCalibHB.png");
1296  cONE->Clear();
1297  }
1298  if (sub == 2) {
1299  cONE->Print("MapRate43TStoAllTSCalibHE.png");
1300  cONE->Clear();
1301  }
1302  if (sub == 3) {
1303  cONE->Print("MapRate43TStoAllTSCalibHO.png");
1304  cONE->Clear();
1305  }
1306  if (sub == 4) {
1307  cONE->Print("MapRate43TStoAllTSCalibHF.png");
1308  cONE->Clear();
1309  }
1310  }
1311  if (test == 15) {
1312  if (sub == 1) {
1313  cONE->Print("MapRateMeanPosCalibHB.png");
1314  cONE->Clear();
1315  }
1316  if (sub == 2) {
1317  cONE->Print("MapRateMeanPosCalibHE.png");
1318  cONE->Clear();
1319  }
1320  if (sub == 3) {
1321  cONE->Print("MapRateMeanPosCalibHO.png");
1322  cONE->Clear();
1323  }
1324  if (sub == 4) {
1325  cONE->Print("MapRateMeanPosCalibHF.png");
1326  cONE->Clear();
1327  }
1328  }
1329  if (test == 16) {
1330  if (sub == 1) {
1331  cONE->Print("MapRateMaxPosCalibHB.png");
1332  cONE->Clear();
1333  }
1334  if (sub == 2) {
1335  cONE->Print("MapRateMaxPosCalibHE.png");
1336  cONE->Clear();
1337  }
1338  if (sub == 3) {
1339  cONE->Print("MapRateMaxPosCalibHO.png");
1340  cONE->Clear();
1341  }
1342  if (sub == 4) {
1343  cONE->Print("MapRateMaxPosCalibHF.png");
1344  cONE->Clear();
1345  }
1346  }
1347 
1348  cONE->Divide(1, 1);
1349  cONE->cd(1);
1350  gPad->SetGridy();
1351  gPad->SetGridx();
1352  gPad->SetLogy();
1353  if (sub == 1)
1354  HistAmpl[test][sub]->SetTitle("HB, All Depth");
1355  if (sub == 2)
1356  HistAmpl[test][sub]->SetTitle("HE, All Depth");
1357  if (sub == 3)
1358  HistAmpl[test][sub]->SetTitle("HO, All Depth");
1359  if (sub == 4)
1360  HistAmpl[test][sub]->SetTitle("HF, All Depth");
1361  if (test == 12)
1362  HistAmpl[test][sub]->SetXTitle("ADC Amlitude in each event & cell \b");
1363  if (test == 13)
1364  HistAmpl[test][sub]->SetXTitle("Amplitude RMS in each event & cell \b");
1365  if (test == 14)
1366  HistAmpl[test][sub]->SetXTitle("Ratio in each event & cell \b");
1367  if (test == 15)
1368  HistAmpl[test][sub]->SetXTitle("Mean TS position in each event & cell \b");
1369  if (test == 16)
1370  HistAmpl[test][sub]->SetXTitle("Max TS position in each event & cell \b");
1371  HistAmpl[test][sub]->SetYTitle("Number of cell-events \b");
1372  HistAmpl[test][sub]->SetLineColor(4);
1373  HistAmpl[test][sub]->SetLineWidth(2);
1374  HistAmpl[test][sub]->SetTitleOffset(1.4, "Y");
1375  HistAmpl[test][sub]->Draw("");
1376  // HistAmpl[test][sub]->GetYaxis()->SetRangeUser(1., 100.);
1377  if (test == 12) {
1378  gPad->SetLogx();
1379  HistAmpl[test][sub]->GetXaxis()->SetRangeUser(1., 10000.);
1380  }
1381  if (test == 13)
1382  HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 5.);
1383  if (test == 14)
1384  HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 1.);
1385  if (test == 15)
1386  HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 9.);
1387  if (test == 16)
1388  HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 9.);
1389  cONE->Modified();
1390  cONE->Update();
1391  double min_x[] = {MIN_C[test - 10][sub], MIN_C[test - 10][sub]};
1392  double min_y[] = {0., 100000000.};
1393  TGraph *MIN = new TGraph(2, min_x, min_y);
1394  MIN->SetLineStyle(2);
1395  MIN->SetLineColor(2);
1396  MIN->SetLineWidth(2 + 100 * 100);
1397  MIN->SetFillStyle(3005);
1398  MIN->SetFillColor(2);
1399  MIN->Draw("L");
1400  double max_x[] = {MAX_C[test - 10][sub], MAX_C[test - 10][sub]};
1401  double max_y[] = {0., 100000000.};
1402  TGraph *MAX = new TGraph(2, max_x, max_y);
1403  MAX->SetLineStyle(2);
1404  MAX->SetLineColor(2);
1405  MAX->SetLineWidth(-2 - 100 * 100);
1406  MAX->SetFillStyle(3004);
1407  MAX->SetFillColor(2);
1408  MAX->Draw("L");
1409  if (test == 12) {
1410  if (sub == 1) {
1411  cONE->Print("HistAmplCalibHB.png");
1412  cONE->Clear();
1413  }
1414  if (sub == 2) {
1415  cONE->Print("HistAmplCalibHE.png");
1416  cONE->Clear();
1417  }
1418  if (sub == 3) {
1419  cONE->Print("HistAmplCalibHO.png");
1420  cONE->Clear();
1421  }
1422  if (sub == 4) {
1423  cONE->Print("HistAmplCalibHF.png");
1424  cONE->Clear();
1425  }
1426  }
1427  if (test == 13) {
1428  if (sub == 1) {
1429  cONE->Print("HistRMSCalibHB.png");
1430  cONE->Clear();
1431  }
1432  if (sub == 2) {
1433  cONE->Print("HistRMSCalibHE.png");
1434  cONE->Clear();
1435  }
1436  if (sub == 3) {
1437  cONE->Print("HistRMSCalibHO.png");
1438  cONE->Clear();
1439  }
1440  if (sub == 4) {
1441  cONE->Print("HistRMSCalibHF.png");
1442  cONE->Clear();
1443  }
1444  }
1445  if (test == 14) {
1446  if (sub == 1) {
1447  cONE->Print("Hist43TStoAllTSCalibHB.png");
1448  cONE->Clear();
1449  }
1450  if (sub == 2) {
1451  cONE->Print("Hist43TStoAllTSCalibHE.png");
1452  cONE->Clear();
1453  }
1454  if (sub == 3) {
1455  cONE->Print("Hist43TStoAllTSCalibHO.png");
1456  cONE->Clear();
1457  }
1458  if (sub == 4) {
1459  cONE->Print("Hist43TStoAllTSCalibHF.png");
1460  cONE->Clear();
1461  }
1462  }
1463  if (test == 15) {
1464  if (sub == 1) {
1465  cONE->Print("HistMeanPosCalibHB.png");
1466  cONE->Clear();
1467  }
1468  if (sub == 2) {
1469  cONE->Print("HistMeanPosCalibHE.png");
1470  cONE->Clear();
1471  }
1472  if (sub == 3) {
1473  cONE->Print("HistMeanPosCalibHO.png");
1474  cONE->Clear();
1475  }
1476  if (sub == 4) {
1477  cONE->Print("HistMeanPosCalibHF.png");
1478  cONE->Clear();
1479  }
1480  }
1481  if (test == 16) {
1482  if (sub == 1) {
1483  cONE->Print("HistMaxPosCalibHB.png");
1484  cONE->Clear();
1485  }
1486  if (sub == 2) {
1487  cONE->Print("HistMaxPosCalibHE.png");
1488  cONE->Clear();
1489  }
1490  if (sub == 3) {
1491  cONE->Print("HistMaxPosCalibHO.png");
1492  cONE->Clear();
1493  }
1494  if (sub == 4) {
1495  cONE->Print("HistMaxPosCalibHF.png");
1496  cONE->Clear();
1497  }
1498  }
1499  } // end sub
1500  } //end test
1501 
1502  //+++++++++++++++++++++++++++++
1503  //Test 21 (GS) Amplitude drift
1504  //+++++++++++++++++++++++++++++
1505 
1506  Map_Ampl[21][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1AmplE34_HB");
1507  Map_Ampl[21][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2AmplE34_HB");
1508  Map_Ampl[21][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3AmplE34_HB");
1509  Map_Ampl[21][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4AmplE34_HB");
1510  Map_Ampl[21][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1AmplE34_HE");
1511  Map_Ampl[21][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2AmplE34_HE");
1512  Map_Ampl[21][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3AmplE34_HE");
1513  Map_Ampl[21][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4AmplE34_HE");
1514  Map_Ampl[21][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5AmplE34_HE");
1515  Map_Ampl[21][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6AmplE34_HE");
1516  Map_Ampl[21][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7AmplE34_HE");
1517  Map_Ampl[21][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4AmplE34_HO");
1518  Map_Ampl[21][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1AmplE34_HF");
1519  Map_Ampl[21][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2AmplE34_HF");
1520  Map_Ampl[21][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3AmplE34_HF");
1521  Map_Ampl[21][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4AmplE34_HF");
1522 
1523  TH2F *Map_RefAmpl[5][ALLDEPTH]; // 2D histogramm for subdet, depth
1524  TH2F *Map_RefSUB[5][ALLDEPTH]; // 2d histogramm for subdet, depth
1525 
1526  Map_RefAmpl[1][1] = (TH2F *)refdir->FindObjectAny("h_mapDepth1AmplE34_HB");
1527  Map_RefAmpl[1][2] = (TH2F *)refdir->FindObjectAny("h_mapDepth2AmplE34_HB");
1528  Map_RefAmpl[1][3] = (TH2F *)refdir->FindObjectAny("h_mapDepth3AmplE34_HB");
1529  Map_RefAmpl[1][4] = (TH2F *)refdir->FindObjectAny("h_mapDepth4AmplE34_HB");
1530  Map_RefAmpl[2][1] = (TH2F *)refdir->FindObjectAny("h_mapDepth1AmplE34_HE");
1531  Map_RefAmpl[2][2] = (TH2F *)refdir->FindObjectAny("h_mapDepth2AmplE34_HE");
1532  Map_RefAmpl[2][3] = (TH2F *)refdir->FindObjectAny("h_mapDepth3AmplE34_HE");
1533  Map_RefAmpl[2][4] = (TH2F *)refdir->FindObjectAny("h_mapDepth4AmplE34_HE");
1534  Map_RefAmpl[2][5] = (TH2F *)refdir->FindObjectAny("h_mapDepth5AmplE34_HE");
1535  Map_RefAmpl[2][6] = (TH2F *)refdir->FindObjectAny("h_mapDepth6AmplE34_HE");
1536  Map_RefAmpl[2][7] = (TH2F *)refdir->FindObjectAny("h_mapDepth7AmplE34_HE");
1537  Map_RefAmpl[3][4] = (TH2F *)refdir->FindObjectAny("h_mapDepth4AmplE34_HO");
1538  Map_RefAmpl[4][1] = (TH2F *)refdir->FindObjectAny("h_mapDepth1AmplE34_HF");
1539  Map_RefAmpl[4][2] = (TH2F *)refdir->FindObjectAny("h_mapDepth2AmplE34_HF");
1540  Map_RefAmpl[4][3] = (TH2F *)refdir->FindObjectAny("h_mapDepth3AmplE34_HF");
1541  Map_RefAmpl[4][4] = (TH2F *)refdir->FindObjectAny("h_mapDepth4AmplE34_HF");
1542 
1543  Map_RefSUB[1][1] = (TH2F *)refdir->FindObjectAny("h_mapDepth1_HB");
1544  Map_RefSUB[1][2] = (TH2F *)refdir->FindObjectAny("h_mapDepth2_HB");
1545  Map_RefSUB[1][3] = (TH2F *)refdir->FindObjectAny("h_mapDepth3_HB");
1546  Map_RefSUB[1][4] = (TH2F *)refdir->FindObjectAny("h_mapDepth4_HB");
1547  Map_RefSUB[2][1] = (TH2F *)refdir->FindObjectAny("h_mapDepth1_HE");
1548  Map_RefSUB[2][2] = (TH2F *)refdir->FindObjectAny("h_mapDepth2_HE");
1549  Map_RefSUB[2][3] = (TH2F *)refdir->FindObjectAny("h_mapDepth3_HE");
1550  Map_RefSUB[2][4] = (TH2F *)refdir->FindObjectAny("h_mapDepth4_HE");
1551  Map_RefSUB[2][5] = (TH2F *)refdir->FindObjectAny("h_mapDepth5_HE");
1552  Map_RefSUB[2][6] = (TH2F *)refdir->FindObjectAny("h_mapDepth6_HE");
1553  Map_RefSUB[2][7] = (TH2F *)refdir->FindObjectAny("h_mapDepth7_HE");
1554  Map_RefSUB[3][4] = (TH2F *)refdir->FindObjectAny("h_mapDepth4_HO");
1555  Map_RefSUB[4][1] = (TH2F *)refdir->FindObjectAny("h_mapDepth1_HF");
1556  Map_RefSUB[4][2] = (TH2F *)refdir->FindObjectAny("h_mapDepth2_HF");
1557  Map_RefSUB[4][3] = (TH2F *)refdir->FindObjectAny("h_mapDepth3_HF");
1558  Map_RefSUB[4][4] = (TH2F *)refdir->FindObjectAny("h_mapDepth4_HF");
1559 
1560  HistAmplDepth[21][1][1] = new TH1F("diffAmpl_Depth1_HB", "", 100, -10., 10.);
1561  HistAmplDepth[21][1][2] = new TH1F("diffAmpl_Depth2_HB", "", 100, -10., 10.);
1562  HistAmplDepth[21][1][3] = new TH1F("diffAmpl_Depth3_HB", "", 100, -10., 10.);
1563  HistAmplDepth[21][1][4] = new TH1F("diffAmpl_Depth4_HB", "", 100, -10., 10.);
1564  HistAmplDepth[21][2][1] = new TH1F("diffAmpl_Depth1_HE", "", 100, -10., 10.);
1565  HistAmplDepth[21][2][2] = new TH1F("diffAmpl_Depth2_HE", "", 100, -10., 10.);
1566  HistAmplDepth[21][2][3] = new TH1F("diffAmpl_Depth3_HE", "", 100, -10., 10.);
1567  HistAmplDepth[21][2][4] = new TH1F("diffAmpl_Depth4_HE", "", 100, -10., 10.);
1568  HistAmplDepth[21][2][5] = new TH1F("diffAmpl_Depth5_HE", "", 100, -10., 10.);
1569  HistAmplDepth[21][2][6] = new TH1F("diffAmpl_Depth6_HE", "", 100, -10., 10.);
1570  HistAmplDepth[21][2][7] = new TH1F("diffAmpl_Depth7_HE", "", 100, -10., 10.);
1571  HistAmplDepth[21][3][4] = new TH1F("diffAmpl_Depth4_HO", "", 100, -10., 10.);
1572  HistAmplDepth[21][4][1] = new TH1F("diffAmpl_Depth1_HF", "", 100, -10., 10.);
1573  HistAmplDepth[21][4][2] = new TH1F("diffAmpl_Depth2_HF", "", 100, -10., 10.);
1574  HistAmplDepth[21][4][3] = new TH1F("diffAmpl_Depth3_HF", "", 100, -10., 10.);
1575  HistAmplDepth[21][4][4] = new TH1F("diffAmpl_Depth4_HF", "", 100, -10., 10.);
1576 
1577  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
1578  // if (sub==1) cHB->Divide(2,1);
1579  if (sub == 1)
1580  cHB->Divide(2, 2);
1581  // if (sub==2) cHE->Divide(3,1);
1582  if (sub == 2)
1583  cHE->Divide(3, 3);
1584  if (sub == 3)
1585  cONE->Divide(1, 1);
1586  // if (sub==4) cHF->Divide(2,1);
1587  if (sub == 4)
1588  cHF->Divide(2, 2);
1589  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
1590  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
1591  // int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
1592  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
1593  if (sub == 1)
1594  cHB->cd(k);
1595  if (sub == 2)
1596  cHE->cd(k);
1597  if (sub == 3)
1598  cONE->cd(k - 3);
1599  if (sub == 4)
1600  cHF->cd(k);
1601  Map_Ampl[21][sub][k]->Divide(Map_Ampl[21][sub][k], Map_SUB[sub][k], 1, 1, "B");
1602  gPad->SetGridy();
1603  gPad->SetGridx();
1604  gPad->SetLogz();
1605  if (sub == 1)
1606  sprintf(str, "HB, Depth%d \b", k);
1607  if (sub == 2)
1608  sprintf(str, "HE, Depth%d \b", k);
1609  if (sub == 3)
1610  sprintf(str, "HO, Depth%d \b", k);
1611  if (sub == 4)
1612  sprintf(str, "HF, Depth%d \b", k);
1613  Map_Ampl[21][sub][k]->SetTitle(str);
1614  Map_Ampl[21][sub][k]->SetXTitle("#eta \b");
1615  Map_Ampl[21][sub][k]->SetYTitle("#phi \b");
1616  Map_Ampl[21][sub][k]->SetZTitle("Response \b");
1617  Map_Ampl[21][sub][k]->SetTitleOffset(1.1, "Z");
1618  Map_Ampl[21][sub][k]->Draw("COLZ");
1619  Map_Ampl[21][sub][k]->GetYaxis()->SetRangeUser(0, 71.);
1620  // Map_Ampl[21][sub][k]->GetZaxis()->SetRangeUser(1., 10.);
1621  if (sub == 1) {
1622  cHB->Modified();
1623  cHB->Update();
1624  }
1625  if (sub == 2) {
1626  cHE->Modified();
1627  cHE->Update();
1628  }
1629  if (sub == 3) {
1630  cONE->Modified();
1631  cONE->Update();
1632  }
1633  if (sub == 4) {
1634  cHF->Modified();
1635  cHF->Update();
1636  }
1637  } //end depth
1638  if (sub == 1) {
1639  cHB->Print("MapRateAmpl1HB.png");
1640  cHB->Clear();
1641  }
1642  if (sub == 2) {
1643  cHE->Print("MapRateAmpl1HE.png");
1644  cHE->Clear();
1645  }
1646  if (sub == 3) {
1647  cONE->Print("MapRateAmpl1HO.png");
1648  cONE->Clear();
1649  }
1650  if (sub == 4) {
1651  cHF->Print("MapRateAmpl1HF.png");
1652  cHF->Clear();
1653  }
1654 
1655  // if (sub==1) cHB->Divide(2,1);
1656  if (sub == 1)
1657  cHB->Divide(2, 2);
1658  // if (sub==2) cHE->Divide(3,1);
1659  if (sub == 2)
1660  cHE->Divide(3, 3);
1661  if (sub == 3)
1662  cONE->Divide(1, 1);
1663  // if (sub==4) cHF->Divide(2,1);
1664  if (sub == 4)
1665  cHF->Divide(2, 2);
1666 
1667  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
1668  if (sub == 1)
1669  cHB->cd(k);
1670  if (sub == 2)
1671  cHE->cd(k);
1672  if (sub == 3)
1673  cONE->cd(k - 3);
1674  if (sub == 4)
1675  cHF->cd(k);
1676  Map_RefAmpl[sub][k]->Divide(Map_RefAmpl[sub][k], Map_RefSUB[sub][k], 1, 1, "B");
1677  gPad->SetGridy();
1678  gPad->SetGridx();
1679  gPad->SetLogz();
1680  if (sub == 1)
1681  sprintf(str, "HB, Depth%d \b", k);
1682  if (sub == 2)
1683  sprintf(str, "HE, Depth%d \b", k);
1684  if (sub == 3)
1685  sprintf(str, "HO, Depth%d \b", k);
1686  if (sub == 4)
1687  sprintf(str, "HF, Depth%d \b", k);
1688  Map_RefAmpl[sub][k]->SetTitle(str);
1689  Map_RefAmpl[sub][k]->SetXTitle("#eta \b");
1690  Map_RefAmpl[sub][k]->SetYTitle("#phi \b");
1691  Map_RefAmpl[sub][k]->SetZTitle("Response\b");
1692  Map_RefAmpl[sub][k]->SetTitleOffset(1.1, "Z");
1693  Map_RefAmpl[sub][k]->Draw("COLZ");
1694  Map_RefAmpl[sub][k]->GetYaxis()->SetRangeUser(0, 71.);
1695  // Map_RefAmpl[21][sub][k]->GetZaxis()->SetRangeUser(1., 10.);
1696  if (sub == 1) {
1697  cHB->Modified();
1698  cHB->Update();
1699  }
1700  if (sub == 2) {
1701  cHE->Modified();
1702  cHE->Update();
1703  }
1704  if (sub == 3) {
1705  cONE->Modified();
1706  cONE->Update();
1707  }
1708  if (sub == 4) {
1709  cHF->Modified();
1710  cHF->Update();
1711  }
1712  } //end depth
1713  if (sub == 1) {
1714  cHB->Print("MapRateAmpl2HB.png");
1715  cHB->Clear();
1716  }
1717  if (sub == 2) {
1718  cHE->Print("MapRateAmpl2HE.png");
1719  cHE->Clear();
1720  }
1721  if (sub == 3) {
1722  cONE->Print("MapRateAmpl2HO.png");
1723  cONE->Clear();
1724  }
1725  if (sub == 4) {
1726  cHF->Print("MapRateAmpl2HF.png");
1727  cHF->Clear();
1728  }
1729 
1730  // if (sub==1) cHB->Divide(2,1);
1731  if (sub == 1)
1732  cHB->Divide(2, 2);
1733  // if (sub==2) cHE->Divide(3,1);
1734  if (sub == 2)
1735  cHE->Divide(3, 3);
1736  if (sub == 3)
1737  cONE->Divide(1, 1);
1738  // if (sub==4) cHF->Divide(2,1);
1739  if (sub == 4)
1740  cHF->Divide(2, 2);
1741 
1742  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
1743  if (sub == 1)
1744  cHB->cd(k);
1745  if (sub == 2)
1746  cHE->cd(k);
1747  if (sub == 3)
1748  cONE->cd(k - 3);
1749  if (sub == 4)
1750  cHF->cd(k);
1751  TH2F *TTT = new TH2F("Map", "Map", 82, -41, 40, 72, 0, 71);
1752  for (int x = 1; x <= Map_Ampl[21][sub][k]->GetXaxis()->GetNbins(); x++) {
1753  for (int y = 1; y <= Map_Ampl[21][sub][k]->GetYaxis()->GetNbins(); y++) {
1754  if (Map_Ampl[21][sub][k]->GetBinContent(x, y) != 0 && Map_RefAmpl[sub][k]->GetBinContent(x, y) != 0) {
1755  double ccc1 = Map_Ampl[21][sub][k]->GetBinContent(x, y) - Map_RefAmpl[sub][k]->GetBinContent(x, y);
1756  ccc1 = 100. * ccc1 / Map_Ampl[21][sub][k]->GetBinContent(x, y); // in %
1757  HistAmplDepth[21][sub][k]->Fill(ccc1);
1758  Map_Ampl[21][sub][k]->SetBinContent(x, y, fabs(ccc1));
1759  if (fabs(ccc1) > porog[sub])
1760  TTT->SetBinContent(x, y, fabs(ccc1));
1761  else
1762  TTT->SetBinContent(x, y, 0);
1763  }
1764  } //end y
1765  } //esnd x
1766  gPad->SetGridy();
1767  gPad->SetGridx();
1768  // gPad->SetLogz();
1769  if (sub == 1)
1770  sprintf(str, "HB, Depth%d \b", k);
1771  if (sub == 2)
1772  sprintf(str, "HE, Depth%d \b", k);
1773  if (sub == 3)
1774  sprintf(str, "HO, Depth%d \b", k);
1775  if (sub == 4)
1776  sprintf(str, "HF, Depth%d \b", k);
1777  TTT->SetTitle(str);
1778  TTT->SetXTitle("#eta \b");
1779  TTT->SetYTitle("#phi \b");
1780  TTT->SetZTitle("Relative difference, % \b");
1781  TTT->SetTitleOffset(0.9, "Z");
1782  TTT->Draw("COLZ");
1783  TTT->GetYaxis()->SetRangeUser(0, 71.);
1784  TTT->GetZaxis()->SetRangeUser(0, 10.);
1785  if (sub == 1) {
1786  cHB->Modified();
1787  cHB->Update();
1788  }
1789  if (sub == 2) {
1790  cHE->Modified();
1791  cHE->Update();
1792  }
1793  if (sub == 3) {
1794  cONE->Modified();
1795  cONE->Update();
1796  }
1797  if (sub == 4) {
1798  cHF->Modified();
1799  cHF->Update();
1800  }
1801  } //end depth
1802 
1803  if (sub == 1) {
1804  cHB->Print("MapRateAmplDriftHB.png");
1805  cHB->Clear();
1806  }
1807  if (sub == 2) {
1808  cHE->Print("MapRateAmplDriftHE.png");
1809  cHE->Clear();
1810  }
1811  if (sub == 3) {
1812  cONE->Print("MapRateAmplDriftHO.png");
1813  cONE->Clear();
1814  }
1815  if (sub == 4) {
1816  cHF->Print("MapRateAmplDriftHF.png");
1817  cHF->Clear();
1818  }
1820 
1821  // if (sub==1) cHB->Divide(2,1);
1822  if (sub == 1)
1823  cHB->Divide(2, 2);
1824  // if (sub==2) cHE->Divide(3,1);
1825  if (sub == 2)
1826  cHE->Divide(3, 3);
1827  if (sub == 3)
1828  cONE->Divide(1, 1);
1829  // if (sub==4) cHF->Divide(2,1);
1830  if (sub == 4)
1831  cHF->Divide(2, 2);
1832 
1833  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
1834  if (sub == 1)
1835  cHB->cd(k);
1836  if (sub == 2)
1837  cHE->cd(k);
1838  if (sub == 3)
1839  cONE->cd(k - 3);
1840  if (sub == 4)
1841  cHF->cd(k);
1842  gPad->SetGridy();
1843  gPad->SetGridx();
1844  gPad->SetLogy();
1845  if (sub == 1)
1846  sprintf(str, "HB, Depth%d \b", k);
1847  if (sub == 2)
1848  sprintf(str, "HE, Depth%d \b", k);
1849  if (sub == 3)
1850  sprintf(str, "HO, Depth%d \b", k);
1851  if (sub == 4)
1852  sprintf(str, "HF, Depth%d \b", k);
1853  HistAmplDepth[21][sub][k]->SetTitle(str);
1854  HistAmplDepth[21][sub][k]->SetYTitle("Number of cell-events \b");
1855  HistAmplDepth[21][sub][k]->SetXTitle("Per cent \b");
1856  HistAmplDepth[21][sub][k]->SetLineColor(4);
1857  HistAmplDepth[21][sub][k]->SetLineWidth(2);
1858  HistAmplDepth[21][sub][k]->SetTitleOffset(1.4, "Y");
1859  HistAmplDepth[21][sub][k]->Draw();
1860  // HistAmplDepth[21][sub][k]->GetYaxis()->SetRangeUser(0, 72.);
1861  HistAmplDepth[21][sub][k]->GetXaxis()->SetRangeUser(-10., 10.);
1862  if (sub == 1) {
1863  cHB->Modified();
1864  cHB->Update();
1865  }
1866  if (sub == 2) {
1867  cHE->Modified();
1868  cHE->Update();
1869  }
1870  if (sub == 3) {
1871  cONE->Modified();
1872  cONE->Update();
1873  }
1874  if (sub == 4) {
1875  cHF->Modified();
1876  cHF->Update();
1877  }
1878  double min_x[] = {-1 * porog[sub], -1 * porog[sub]};
1879  double min_y[] = {0., 100000000.};
1880  TGraph *MIN = new TGraph(2, min_x, min_y);
1881  MIN->SetLineStyle(2);
1882  MIN->SetLineColor(2);
1883  MIN->SetLineWidth(2 + 100 * 100);
1884  MIN->SetFillStyle(3005);
1885  MIN->SetFillColor(2);
1886  MIN->Draw("L");
1887  double max_x[] = {porog[sub], porog[sub]};
1888  double max_y[] = {0., 100000000.};
1889  TGraph *MAX = new TGraph(2, max_x, max_y);
1890  MAX->SetLineStyle(2);
1891  MAX->SetLineColor(2);
1892  MAX->SetLineWidth(-2 - 100 * 100);
1893  MAX->SetFillStyle(3004);
1894  MAX->SetFillColor(2);
1895  MAX->Draw("L");
1896  } // end depth
1897  if (sub == 1) {
1898  cHB->Print("HistAmplDriftDepthHB.png");
1899  cHB->Clear();
1900  }
1901  if (sub == 2) {
1902  cHE->Print("HistAmplDriftDepthHE.png");
1903  cHE->Clear();
1904  }
1905  if (sub == 3) {
1906  cONE->Print("HistAmplDriftDepthHO.png");
1907  cONE->Clear();
1908  }
1909  if (sub == 4) {
1910  cHF->Print("HistAmplDriftDepthHF.png");
1911  cHF->Clear();
1912  }
1913  } //end sub
1914 
1915  //+++++++++++++++++++++++++++++++++++
1916  //Test 31, 32 Pedestal, pedestalWidths
1917  //++++++++++++++++++++++++++++++++++++
1918 
1919  Map_Ampl[31][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1pedestal_HB");
1920  Map_Ampl[31][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2pedestal_HB");
1921  Map_Ampl[31][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3pedestal_HB");
1922  Map_Ampl[31][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4pedestal_HB");
1923  Map_Ampl[31][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1pedestal_HE");
1924  Map_Ampl[31][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2pedestal_HE");
1925  Map_Ampl[31][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3pedestal_HE");
1926  Map_Ampl[31][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4pedestal_HE");
1927  Map_Ampl[31][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5pedestal_HE");
1928  Map_Ampl[31][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6pedestal_HE");
1929  Map_Ampl[31][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7pedestal_HE");
1930  Map_Ampl[31][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4pedestal_HO");
1931  Map_Ampl[31][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1pedestal_HF");
1932  Map_Ampl[31][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2pedestal_HF");
1933  Map_Ampl[31][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3pedestal_HF");
1934  Map_Ampl[31][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4pedestal_HF");
1935 
1936  Map_Ampl[32][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1pedestalw_HB");
1937  Map_Ampl[32][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2pedestalw_HB");
1938  Map_Ampl[32][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3pedestalw_HB");
1939  Map_Ampl[32][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4pedestalw_HB");
1940  Map_Ampl[32][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1pedestalw_HE");
1941  Map_Ampl[32][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2pedestalw_HE");
1942  Map_Ampl[32][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3pedestalw_HE");
1943  Map_Ampl[32][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4pedestalw_HE");
1944  Map_Ampl[32][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5pedestalw_HE");
1945  Map_Ampl[32][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6pedestalw_HE");
1946  Map_Ampl[32][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7pedestalw_HE");
1947  Map_Ampl[32][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4pedestalw_HO");
1948  Map_Ampl[32][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1pedestalw_HF");
1949  Map_Ampl[32][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2pedestalw_HF");
1950  Map_Ampl[32][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3pedestalw_HF");
1951  Map_Ampl[32][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4pedestalw_HF");
1952 
1953  HistPed[1][1][0] = (TH1F *)dir->FindObjectAny("h_pedestal0_HB");
1954  HistPed[1][1][1] = (TH1F *)dir->FindObjectAny("h_pedestal1_HB");
1955  HistPed[1][1][2] = (TH1F *)dir->FindObjectAny("h_pedestal2_HB");
1956  HistPed[1][1][3] = (TH1F *)dir->FindObjectAny("h_pedestal3_HB");
1957  HistPed[2][1][0] = (TH1F *)dir->FindObjectAny("h_pedestalw0_HB");
1958  HistPed[2][1][1] = (TH1F *)dir->FindObjectAny("h_pedestalw1_HB");
1959  HistPed[2][1][2] = (TH1F *)dir->FindObjectAny("h_pedestalw2_HB");
1960  HistPed[2][1][3] = (TH1F *)dir->FindObjectAny("h_pedestalw3_HB");
1961 
1962  HistPed[1][2][0] = (TH1F *)dir->FindObjectAny("h_pedestal0_HE");
1963  HistPed[1][2][1] = (TH1F *)dir->FindObjectAny("h_pedestal1_HE");
1964  HistPed[1][2][2] = (TH1F *)dir->FindObjectAny("h_pedestal2_HE");
1965  HistPed[1][2][3] = (TH1F *)dir->FindObjectAny("h_pedestal3_HE");
1966  HistPed[2][2][0] = (TH1F *)dir->FindObjectAny("h_pedestalw0_HE");
1967  HistPed[2][2][1] = (TH1F *)dir->FindObjectAny("h_pedestalw1_HE");
1968  HistPed[2][2][2] = (TH1F *)dir->FindObjectAny("h_pedestalw2_HE");
1969  HistPed[2][2][3] = (TH1F *)dir->FindObjectAny("h_pedestalw3_HE");
1970 
1971  HistPed[1][3][0] = (TH1F *)dir->FindObjectAny("h_pedestal0_HO");
1972  HistPed[1][3][1] = (TH1F *)dir->FindObjectAny("h_pedestal1_HO");
1973  HistPed[1][3][2] = (TH1F *)dir->FindObjectAny("h_pedestal2_HO");
1974  HistPed[1][3][3] = (TH1F *)dir->FindObjectAny("h_pedestal3_HO");
1975  HistPed[2][3][0] = (TH1F *)dir->FindObjectAny("h_pedestalw0_HO");
1976  HistPed[2][3][1] = (TH1F *)dir->FindObjectAny("h_pedestalw1_HO");
1977  HistPed[2][3][2] = (TH1F *)dir->FindObjectAny("h_pedestalw2_HO");
1978  HistPed[2][3][3] = (TH1F *)dir->FindObjectAny("h_pedestalw3_HO");
1979 
1980  HistPed[1][4][0] = (TH1F *)dir->FindObjectAny("h_pedestal0_HF");
1981  HistPed[1][4][1] = (TH1F *)dir->FindObjectAny("h_pedestal1_HF");
1982  HistPed[1][4][2] = (TH1F *)dir->FindObjectAny("h_pedestal2_HF");
1983  HistPed[1][4][3] = (TH1F *)dir->FindObjectAny("h_pedestal3_HF");
1984  HistPed[2][4][0] = (TH1F *)dir->FindObjectAny("h_pedestalw0_HF");
1985  HistPed[2][4][1] = (TH1F *)dir->FindObjectAny("h_pedestalw1_HF");
1986  HistPed[2][4][2] = (TH1F *)dir->FindObjectAny("h_pedestalw2_HF");
1987  HistPed[2][4][3] = (TH1F *)dir->FindObjectAny("h_pedestalw3_HF");
1988 
1989  for (int test = 31; test <= 32; test++) { //Test: 31-Pedestals, 32-pedestal Widths,
1990  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
1991  // if (sub==1) cHB->Divide(2,1);
1992  if (sub == 1)
1993  cHB->Divide(2, 2);
1994  // if (sub==2) cHE->Divide(3,1);
1995  if (sub == 2)
1996  cHE->Divide(3, 3);
1997  if (sub == 3)
1998  cONE->Divide(1, 1);
1999  // if (sub==4) cHF->Divide(2,1);
2000  if (sub == 4)
2001  cHF->Divide(2, 2);
2002  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
2003  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
2004  // int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
2005  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depths
2006  if (sub == 1)
2007  cHB->cd(k);
2008  if (sub == 2)
2009  cHE->cd(k);
2010  if (sub == 3)
2011  cONE->cd(k - 3);
2012  if (sub == 4)
2013  cHF->cd(k);
2014  Map_Ampl[test][sub][k]->Divide(Map_Ampl[test][sub][k], Map_SUB[sub][k], 1, 1, "B");
2015  gPad->SetGridy();
2016  gPad->SetGridx();
2017  gPad->SetLogz();
2018  if (sub == 1)
2019  sprintf(str, "HB, Depth%d \b", k);
2020  if (sub == 2)
2021  sprintf(str, "HE, Depth%d \b", k);
2022  if (sub == 3)
2023  sprintf(str, "HO, Depth%d \b", k);
2024  if (sub == 4)
2025  sprintf(str, "HF, Depth%d \b", k);
2026  Map_Ampl[test][sub][k]->SetTitle(str);
2027  Map_Ampl[test][sub][k]->SetXTitle("#eta \b");
2028  Map_Ampl[test][sub][k]->SetYTitle("#phi \b");
2029  Map_Ampl[test][sub][k]->SetZTitle("Rate \b");
2030  if (sub == 3)
2031  Map_Ampl[test][sub][k]->SetTitleOffset(0.8, "Z");
2032  Map_Ampl[test][sub][k]->Draw("COLZ");
2033  Map_Ampl[test][sub][k]->GetYaxis()->SetRangeUser(0, 72.);
2034  Map_Ampl[test][sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
2035  if (sub == 1) {
2036  cHB->Modified();
2037  cHB->Update();
2038  }
2039  if (sub == 2) {
2040  cHE->Modified();
2041  cHE->Update();
2042  }
2043  if (sub == 3) {
2044  cONE->Modified();
2045  cONE->Update();
2046  }
2047  if (sub == 4) {
2048  cHF->Modified();
2049  cHF->Update();
2050  }
2051  } //end depth
2052  if (test == 31) {
2053  if (sub == 1) {
2054  cHB->Print("MapRatePedHB.png");
2055  cHB->Clear();
2056  }
2057  if (sub == 2) {
2058  cHE->Print("MapRatePedHE.png");
2059  cHE->Clear();
2060  }
2061  if (sub == 3) {
2062  cONE->Print("MapRatePedHO.png");
2063  cONE->Clear();
2064  }
2065  if (sub == 4) {
2066  cHF->Print("MapRatePedHF.png");
2067  cHF->Clear();
2068  }
2069  }
2070  if (test == 32) {
2071  if (sub == 1) {
2072  cHB->Print("MapRatePedWidthsHB.png");
2073  cHB->Clear();
2074  }
2075  if (sub == 2) {
2076  cHE->Print("MapRatePedWidthsHE.png");
2077  cHE->Clear();
2078  }
2079  if (sub == 3) {
2080  cONE->Print("MapRatePedWidthsHO.png");
2081  cONE->Clear();
2082  }
2083  if (sub == 4) {
2084  cHF->Print("MapRatePedWidthsHF.png");
2085  cHF->Clear();
2086  }
2087  }
2088 
2090 
2091  cPED->Divide(2, 2);
2092  for (int cap = 0; cap <= 3; cap++) {
2093  cPED->cd(cap + 1);
2094  gPad->SetGridy();
2095  gPad->SetGridx();
2096  gPad->SetLogy();
2097 
2098  if (sub == 1)
2099  sprintf(str, "HB, Cap%d, all depth\b", cap);
2100  if (sub == 2)
2101  sprintf(str, "HE, Cap%d, all depth\b", cap);
2102  if (sub == 3)
2103  sprintf(str, "HO, Cap%d, all depth\b", cap);
2104  if (sub == 4)
2105  sprintf(str, "HF, Cap%d, all depth\b", cap);
2106 
2107  HistPed[test - 30][sub][cap]->SetTitle(str);
2108 
2109  if (test == 31)
2110  HistPed[test - 30][sub][cap]->SetXTitle("Pedestals in each event & cell \b");
2111  if (test == 32)
2112  HistPed[test - 30][sub][cap]->SetXTitle("Pedestal Widths in each event & cell \b");
2113 
2114  HistPed[test - 30][sub][cap]->SetYTitle("Number of channel-events \b");
2115  HistPed[test - 30][sub][cap]->SetLineColor(4);
2116  HistPed[test - 30][sub][cap]->SetLineWidth(2);
2117  HistPed[test - 30][sub][cap]->SetTitleOffset(1.4, "Y");
2118  HistPed[test - 30][sub][cap]->Draw("");
2119  // HistPed[test-30][sub][cap]->GetYaxis()->SetRangeUser(1., 100.);
2120  // if (test==31) {gPad->SetLogx(); HistPed[test-30][sub][cap]->GetXaxis()->SetRangeUser(1., 10000.);}
2121  // if (test==32) HistPed[test-30][sub][cap]->GetXaxis()->SetRangeUser(0., 5.);
2122 
2123  cPED->Modified();
2124  cPED->Update();
2125  double min_x[] = {Pedest[test - 31][sub], Pedest[test - 31][sub]};
2126  double min_y[] = {0., 100000000.};
2127  TGraph *MIN = new TGraph(2, min_x, min_y);
2128  MIN->SetLineStyle(2);
2129  MIN->SetLineColor(2);
2130  MIN->SetLineWidth(2 + 100 * 100);
2131  MIN->SetFillStyle(3005);
2132  MIN->SetFillColor(2);
2133  MIN->Draw("L");
2134  }
2135  if (test == 31) {
2136  if (sub == 1) {
2137  cPED->Print("HistPedestalsHB.png");
2138  cPED->Clear();
2139  }
2140  if (sub == 2) {
2141  cPED->Print("HistPedestalsHE.png");
2142  cPED->Clear();
2143  }
2144  if (sub == 3) {
2145  cPED->Print("HistPedestalsHO.png");
2146  cPED->Clear();
2147  }
2148  if (sub == 4) {
2149  cPED->Print("HistPedestalsHF.png");
2150  cPED->Clear();
2151  }
2152  }
2153  if (test == 32) {
2154  if (sub == 1) {
2155  cPED->Print("HistPedestalWidthsHB.png");
2156  cPED->Clear();
2157  }
2158  if (sub == 2) {
2159  cPED->Print("HistPedestalWidthsHE.png");
2160  cPED->Clear();
2161  }
2162  if (sub == 3) {
2163  cPED->Print("HistPedestalWidthsHO.png");
2164  cPED->Clear();
2165  }
2166  if (sub == 4) {
2167  cPED->Print("HistPedestalWidthsHF.png");
2168  cPED->Clear();
2169  }
2170  }
2171  } // end sub
2172  } //end test 31,32
2173 
2174  //+++++++++++++++++++++++++++++++++++
2175  //Test 33 Correlation of Pedestal, pedestalWidths Vs fullAmplitude
2176  //++++++++++++++++++++++++++++++++++++
2177 
2178  cPED->Clear();
2179  Map_Ped[1][1] = (TH2F *)dir->FindObjectAny("h2_pedvsampl_HB");
2180  Map_Ped[1][2] = (TH2F *)dir->FindObjectAny("h2_pedvsampl_HE");
2181  Map_Ped[1][3] = (TH2F *)dir->FindObjectAny("h2_pedvsampl_HO");
2182  Map_Ped[1][4] = (TH2F *)dir->FindObjectAny("h2_pedvsampl_HF");
2183  Map_Ped[2][1] = (TH2F *)dir->FindObjectAny("h2_pedwvsampl_HB");
2184  Map_Ped[2][2] = (TH2F *)dir->FindObjectAny("h2_pedwvsampl_HE");
2185  Map_Ped[2][3] = (TH2F *)dir->FindObjectAny("h2_pedwvsampl_HO");
2186  Map_Ped[2][4] = (TH2F *)dir->FindObjectAny("h2_pedwvsampl_HF");
2187  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
2188  cPED->Divide(2, 1);
2189  for (int test = 1; test <= 2; test++) {
2190  cPED->cd(test);
2191  gPad->SetGridy();
2192  gPad->SetGridx();
2193  gPad->SetLogz();
2194  if (test == 1)
2195  Map_Ped[test][sub]->SetXTitle("Pedestal, fC \b");
2196  if (test == 2)
2197  Map_Ped[test][sub]->SetXTitle("pedestal Width, fC \b");
2198  Map_Ped[test][sub]->SetYTitle("Amplitude, fC \b");
2199  Map_Ped[test][sub]->SetZTitle("entries \b");
2200  if (test == 1)
2201  sprintf(str, "Cap0 Pedestal vs Amplitude \b");
2202  if (test == 2)
2203  sprintf(str, "Cap0 pedestalWidth vs Amplitude \b");
2204  Map_Ped[test][sub]->SetTitle(str);
2205  Map_Ped[test][sub]->Draw("COLZ");
2206  // Map_Ped[test][sub]->GetYaxis()->SetRangeUser(0, 72.);
2207  // Map_Ped[test][sub]->GetZaxis()->SetRangeUser(0.0001, 1.);
2208  cPED->Modified();
2209  cPED->Update();
2210  } // test 1,2
2211  if (sub == 1) {
2212  cPED->Print("CorrelationsMapPedestalVsfullAmplitudeHB.png");
2213  cPED->Clear();
2214  }
2215  if (sub == 2) {
2216  cPED->Print("CorrelationsMapPedestalVsfullAmplitudeHE.png");
2217  cPED->Clear();
2218  }
2219  if (sub == 3) {
2220  cPED->Print("CorrelationsMapPedestalVsfullAmplitudeHO.png");
2221  cPED->Clear();
2222  }
2223  if (sub == 4) {
2224  cPED->Print("CorrelationsMapPedestalVsfullAmplitudeHF.png");
2225  cPED->Clear();
2226  }
2227  } // end sub
2228 
2229  //+++++++++++++++++++++++++++++++++++
2230  //Test 41 Time Slices shape for good and bad channels
2231  //++++++++++++++++++++++++++++++++++++
2232 
2233  cONE->Clear();
2234  hist_GoodTSshape[1] = (TH1F *)dir->FindObjectAny("h_shape_good_channels_HB");
2235  hist_GoodTSshape[2] = (TH1F *)dir->FindObjectAny("h_shape_good_channels_HE");
2236  hist_GoodTSshape[3] = (TH1F *)dir->FindObjectAny("h_shape_good_channels_HO");
2237  hist_GoodTSshape[4] = (TH1F *)dir->FindObjectAny("h_shape_good_channels_HF");
2238 
2239  hist_GoodTSshape0[1] = (TH1F *)dir->FindObjectAny("h_shape0_good_channels_HB");
2240  hist_GoodTSshape0[2] = (TH1F *)dir->FindObjectAny("h_shape0_good_channels_HE");
2241  hist_GoodTSshape0[3] = (TH1F *)dir->FindObjectAny("h_shape0_good_channels_HO");
2242  hist_GoodTSshape0[4] = (TH1F *)dir->FindObjectAny("h_shape0_good_channels_HF");
2243 
2244  hist_BadTSshape[1] = (TH1F *)dir->FindObjectAny("h_shape_bad_channels_HB");
2245  hist_BadTSshape[2] = (TH1F *)dir->FindObjectAny("h_shape_bad_channels_HE");
2246  hist_BadTSshape[3] = (TH1F *)dir->FindObjectAny("h_shape_bad_channels_HO");
2247  hist_BadTSshape[4] = (TH1F *)dir->FindObjectAny("h_shape_bad_channels_HF");
2248 
2249  hist_BadTSshape0[1] = (TH1F *)dir->FindObjectAny("h_shape0_bad_channels_HB");
2250  hist_BadTSshape0[2] = (TH1F *)dir->FindObjectAny("h_shape0_bad_channels_HE");
2251  hist_BadTSshape0[3] = (TH1F *)dir->FindObjectAny("h_shape0_bad_channels_HO");
2252  hist_BadTSshape0[4] = (TH1F *)dir->FindObjectAny("h_shape0_bad_channels_HF");
2253 
2254  cONE->cd(1);
2255 
2256  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
2257 
2258  gPad->SetGridy();
2259  gPad->SetGridx();
2260  gPad->SetLogz();
2261  hist_GoodTSshape[sub]->Divide(hist_GoodTSshape[sub], hist_GoodTSshape0[sub], 1, 1, "B");
2262  hist_GoodTSshape[sub]->SetXTitle("Time slice \b");
2263  hist_GoodTSshape[sub]->SetYTitle("ADC counts \b");
2264  sprintf(str, "Mean ADC Shape \b");
2265  hist_GoodTSshape[sub]->SetTitle(str);
2266  hist_GoodTSshape[sub]->Draw("");
2267  // hist_GoodTSshape[sub]->GetYaxis()->SetRangeUser(0, 72.);
2268  // hist_GoodTSshape[sub]->GetZaxis()->SetRangeUser(0.0001, 1.);
2269  cONE->Modified();
2270  cONE->Update();
2271  if (sub == 1) {
2272  cONE->Print("HistGoodTSshapesHB.png");
2273  cONE->Clear();
2274  }
2275  if (sub == 2) {
2276  cONE->Print("HistGoodTSshapesHE.png");
2277  cONE->Clear();
2278  }
2279  if (sub == 3) {
2280  cONE->Print("HistGoodTSshapesHO.png");
2281  cONE->Clear();
2282  }
2283  if (sub == 4) {
2284  cONE->Print("HistGoodTSshapesHF.png");
2285  cONE->Clear();
2286  }
2287  } // end sub
2288 
2289  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
2290 
2291  gPad->SetGridy();
2292  gPad->SetGridx();
2293  gPad->SetLogz();
2294  hist_BadTSshape[sub]->Divide(hist_BadTSshape[sub], hist_BadTSshape0[sub], 1, 1, "B");
2295  hist_BadTSshape[sub]->SetXTitle("Time slice \b");
2296  hist_BadTSshape[sub]->SetYTitle("ADC counts \b");
2297  sprintf(str, "Mean ADC Shape \b");
2298  hist_BadTSshape[sub]->SetTitle(str);
2299  hist_BadTSshape[sub]->Draw("");
2300  // hist_BadTSshape[sub]->GetYaxis()->SetRangeUser(0, 72.);
2301  // hist_BadTSshape[sub]->GetZaxis()->SetRangeUser(0.0001, 1.);
2302  cONE->Modified();
2303  cONE->Update();
2304  if (sub == 1) {
2305  cONE->Print("HistBadTSshapesHB.png");
2306  cONE->Clear();
2307  }
2308  if (sub == 2) {
2309  cONE->Print("HistBadTSshapesHE.png");
2310  cONE->Clear();
2311  }
2312  if (sub == 3) {
2313  cONE->Print("HistBadTSshapesHO.png");
2314  cONE->Clear();
2315  }
2316  if (sub == 4) {
2317  cONE->Print("HistBadTSshapesHF.png");
2318  cONE->Clear();
2319  }
2320  } // end sub
2321 
2322  //+++++++++++++++++++++++++++++
2323  // Entries in different TSs:
2324  //+++++++++++++++++++++++++++++
2325  Map_SUBTS[1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TS2_HB");
2326  Map_SUBTS[1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TS2_HB");
2327  Map_SUBTS[1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TS2_HB");
2328  Map_SUBTS[1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TS2_HB");
2329 
2330  Map_SUBTS[2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TS2_HE");
2331  Map_SUBTS[2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TS2_HE");
2332  Map_SUBTS[2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TS2_HE");
2333  Map_SUBTS[2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TS2_HE");
2334  Map_SUBTS[2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5TS2_HE");
2335  Map_SUBTS[2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6TS2_HE");
2336  Map_SUBTS[2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7TS2_HE");
2337 
2338  Map_SUBTS[3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TS012_HO");
2339 
2340  Map_SUBTS[4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TS1_HF");
2341  Map_SUBTS[4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TS1_HF");
2342  Map_SUBTS[4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TS1_HF");
2343  Map_SUBTS[4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TS1_HF");
2344 
2346  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
2347  // if (sub==1) cHB->Divide(2,1);
2348  if (sub == 1)
2349  cHB->Divide(2, 2);
2350  // if (sub==2) cHE->Divide(3,1);
2351  if (sub == 2)
2352  cHE->Divide(3, 3);
2353  if (sub == 3)
2354  cONE->Divide(1, 1);
2355  // if (sub==4) cHF->Divide(2,1);
2356  if (sub == 4)
2357  cHF->Divide(2, 2);
2358  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
2359  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
2360  // int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
2361  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
2362  if (sub == 1)
2363  cHB->cd(k);
2364  if (sub == 2)
2365  cHE->cd(k);
2366  if (sub == 3)
2367  cONE->cd(k - 3);
2368  if (sub == 4)
2369  cHF->cd(k);
2370  Map_SUBTS[sub][k]->Divide(Map_SUBTS[sub][k], Map_SUB[sub][k], 1, 1, "B");
2371  gPad->SetGridy();
2372  gPad->SetGridx();
2373  gPad->SetLogz();
2374  if (sub == 1)
2375  sprintf(str, "HB, Depth%d \b", k);
2376  if (sub == 2)
2377  sprintf(str, "HE, Depth%d \b", k);
2378  if (sub == 3)
2379  sprintf(str, "HO, Depth%d \b", k);
2380  if (sub == 4)
2381  sprintf(str, "HF, Depth%d \b", k);
2382  Map_SUBTS[sub][k]->SetTitle(str);
2383  Map_SUBTS[sub][k]->SetXTitle("#eta \b");
2384  Map_SUBTS[sub][k]->SetYTitle("#phi \b");
2385  Map_SUBTS[sub][k]->SetZTitle("Rate \b");
2386  if (sub == 3)
2387  Map_SUBTS[sub][k]->SetTitleOffset(0.8, "Z");
2388  Map_SUBTS[sub][k]->Draw("COLZ");
2389  Map_SUBTS[sub][k]->GetYaxis()->SetRangeUser(0, 72.);
2390  Map_SUBTS[sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
2391  if (sub == 1) {
2392  cHB->Modified();
2393  cHB->Update();
2394  }
2395  if (sub == 2) {
2396  cHE->Modified();
2397  cHE->Update();
2398  }
2399  if (sub == 3) {
2400  cONE->Modified();
2401  cONE->Update();
2402  }
2403  if (sub == 4) {
2404  cHF->Modified();
2405  cHF->Update();
2406  }
2407  } //end depth
2408 
2409  if (sub == 1) {
2410  cHB->Print("Hist_mapDepthAllTS2_HB.png");
2411  cHB->Clear();
2412  }
2413  if (sub == 2) {
2414  cHE->Print("Hist_mapDepthAllTS2_HE.png");
2415  cHE->Clear();
2416  }
2417  if (sub == 3) {
2418  cONE->Print("Hist_mapDepthAllTS012_HO.png");
2419  cONE->Clear();
2420  }
2421  if (sub == 4) {
2422  cHF->Print("Hist_mapDepthAllTS1_HF.png");
2423  cHF->Clear();
2424  }
2425  } // end sub
2426 
2428 
2429  /*
2430  //+++++++++++++++++++++++++++++++++++
2431 //Test 42 ADC in TS distributions
2432 //++++++++++++++++++++++++++++++++++++
2433 
2434 std::cout<<" We are here to print ADC "<<std::endl;
2435 
2436  hist_ADC_All[1] = (TH1F*)dir->FindObjectAny("h_ADC_HB");
2437  hist_ADC_All[2] = (TH1F*)dir->FindObjectAny("h_ADC_HE");
2438  hist_ADC_All[3] = (TH1F*)dir->FindObjectAny("h_ADC_HO");
2439  hist_ADC_All[4] = (TH1F*)dir->FindObjectAny("h_ADC_HF");
2440 
2441 
2442  hist_ADC_DS[1][1] = (TH1F*)dir->FindObjectAny("h_ADC_HBdepth1");
2443  hist_ADC_DS[1][2] = (TH1F*)dir->FindObjectAny("h_ADC_HBdepth2");
2444  hist_ADC_DS[2][1] = (TH1F*)dir->FindObjectAny("h_ADC_HEdepth1");
2445  hist_ADC_DS[2][2] = (TH1F*)dir->FindObjectAny("h_ADC_HEdepth2");
2446  hist_ADC_DS[2][3] = (TH1F*)dir->FindObjectAny("h_ADC_HEdepth3");
2447  hist_ADC_DS[3][4] = (TH1F*)dir->FindObjectAny("h_ADC_HOdepth4");
2448  hist_ADC_DS[4][1] = (TH1F*)dir->FindObjectAny("h_ADC_HFdepth1");
2449  hist_ADC_DS[4][2] = (TH1F*)dir->FindObjectAny("h_ADC_HFdepth2");
2450 
2451 
2452  cONE->Clear();
2453  cONE->Divide(1,1);
2454  cONE->cd(1);
2455 
2456  for (int sub=1;sub<=4;sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
2457  gPad->SetGridy();
2458  gPad->SetGridx();
2459  gPad->SetLogy();
2460  hist_ADC_All[sub]->SetXTitle("ADC counts \b");
2461  hist_ADC_All[sub]->SetYTitle("Number of channels-events \b");
2462  if (sub==1) sprintf(str,"ADC counts Distribution HB\b");
2463  if (sub==2) sprintf(str,"ADC counts Distribution HE\b");
2464  if (sub==3) sprintf(str,"ADC counts Distribution HO\b");
2465  if (sub==4) sprintf(str,"ADC counts Distribution HF\b");
2466  hist_ADC_All[sub]->SetTitle(str);
2467  hist_ADC_All[sub]->Draw("");
2468  // hist_ADC_All[sub]->GetYaxis()->SetRangeUser(0, 72.);
2469  hist_ADC_All[sub]->GetXaxis()->SetRangeUser(0.000, 1000.);
2470  cONE->Modified(); cONE->Update();
2471  if (sub==1) {cONE->Print("Hist_ADC_HB_All.png"); cONE->Clear();}
2472  if (sub==2) {cONE->Print("Hist_ADC_HE_All.png"); cONE->Clear();}
2473  if (sub==3) {cONE->Print("Hist_ADC_HO_All.png"); cONE->Clear();}
2474  if (sub==4) {cONE->Print("Hist_ADC_HF_All.png"); cONE->Clear();}
2475  }// end sub
2476 
2477 
2478  for (int sub=1;sub<=4;sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
2479  if (sub==1) cHB->Divide(2,1);
2480  if (sub==2) cHE->Divide(3,1);
2481  if (sub==3) cONE->Divide(1,1);
2482  if (sub==4) cHB->Divide(2,1);
2483  int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
2484  int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
2485  for (int k=k_min[sub];k<=k_max[sub];k++) { //Depths
2486  if (sub==1) cHB->cd(k);
2487  if (sub==2) cHE->cd(k);
2488  if (sub==3) cONE->cd(k-3);
2489  if (sub==4) cHB->cd(k);
2490  gPad->SetGridy();
2491  gPad->SetGridx();
2492  gPad->SetLogy();
2493  hist_ADC_DS[sub][k]->SetXTitle("ADC counts \b");
2494  hist_ADC_DS[sub][k]->SetYTitle("Number of channels-events \b");
2495  if (sub==1) sprintf(str,"HB, Depth%d \b", k);
2496  if (sub==2) sprintf(str,"HE, Depth%d \b", k);
2497  if (sub==3) sprintf(str,"HO, Depth%d \b", k);
2498  if (sub==4) sprintf(str,"HF, Depth%d \b", k);
2499  hist_ADC_DS[sub][k]->SetTitle(str);
2500  hist_ADC_DS[sub][k]->Draw("");
2501  // hist_ADC_DS[sub][k]->GetYaxis()->SetRangeUser(0, 72.);
2502  hist_ADC_DS[sub][k]->GetXaxis()->SetRangeUser(0.000, 1000.);
2503  if (sub==1) {cHB->Modified(); cHB->Update();}
2504  if (sub==2) {cHE->Modified(); cHE->Update();}
2505  if (sub==3) {cONE->Modified();cONE->Update();}
2506  if (sub==4) {cHB->Modified(); cHB->Update();}
2507  }//end depth
2508  if (sub==1) {cHB->Print("Hist_ADC_HB_DS.png"); cHB->Clear();}
2509  if (sub==2) {cHE->Print("Hist_ADC_HE_DS.png"); cHE->Clear();}
2510  if (sub==3) {cONE->Print("Hist_ADC_HO_DS.png"); cONE->Clear();}
2511  if (sub==4) {cHB->Print("Hist_ADC_HF_DS.png"); cHB->Clear();}
2512  }// end sub
2513 
2514 
2515  //+++++++++++++++++++++++++++++++++++
2516 //Test 43 Sum ADC in TS distributions
2517 //++++++++++++++++++++++++++++++++++++
2518 
2519  hist_SumADC[1][1] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth1_HB");
2520  hist_SumADC[1][2] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth2_HB");
2521  hist_SumADC[2][1] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth1_HE");
2522  hist_SumADC[2][2] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth2_HE");
2523  hist_SumADC[2][3] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth3_HE");
2524  hist_SumADC[3][4] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth4_HO");
2525  hist_SumADC[4][1] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth1_HF");
2526  hist_SumADC[4][2] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth2_HF");
2527 
2528  hist_SumADC0[1][1] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth1_HB0");
2529  hist_SumADC0[1][2] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth2_HB0");
2530  hist_SumADC0[2][1] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth1_HE0");
2531  hist_SumADC0[2][2] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth2_HE0");
2532  hist_SumADC0[2][3] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth3_HE0");
2533  hist_SumADC0[3][4] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth4_HO0");
2534  hist_SumADC0[4][1] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth1_HF0");
2535  hist_SumADC0[4][2] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth2_HF0");
2536 
2537  hist_SumADC1[1][1] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth1_HB1");
2538  hist_SumADC1[1][2] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth2_HB1");
2539  hist_SumADC1[2][1] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth1_HE1");
2540  hist_SumADC1[2][2] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth2_HE1");
2541  hist_SumADC1[2][3] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth3_HE1");
2542  hist_SumADC1[3][4] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth4_HO1");
2543  hist_SumADC1[4][1] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth1_HF1");
2544  hist_SumADC1[4][2] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth2_HF1");
2545 
2546  for (int sub=1;sub<=4;sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
2547  if (sub==1) cHB->Divide(2,1);
2548  if (sub==2) cHE->Divide(3,1);
2549  if (sub==3) cONE->Divide(1,1);
2550  if (sub==4) cHB->Divide(2,1);
2551  int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
2552  int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
2553  for (int k=k_min[sub];k<=k_max[sub];k++) { //Depths
2554  if (sub==1) cHB->cd(k);
2555  if (sub==2) cHE->cd(k);
2556  if (sub==3) cONE->cd(k-3);
2557  if (sub==4) cHB->cd(k);
2558  gPad->SetGridy();
2559  gPad->SetGridx();
2560  gPad->SetLogy();
2561  hist_SumADC[sub][k]->SetXTitle("ADC sum \b");
2562  hist_SumADC[sub][k]->SetYTitle("Number of channels-events \b");
2563  if (sub==1) sprintf(str,"HB, Depth%d \b", k);
2564  if (sub==2) sprintf(str,"HE, Depth%d \b", k);
2565  if (sub==3) sprintf(str,"HO, Depth%d \b", k);
2566  if (sub==4) sprintf(str,"HF, Depth%d \b", k);
2567  hist_SumADC[sub][k]->SetTitle(str);
2568  hist_SumADC[sub][k]->Draw("");
2569  // hist_SumADC[sub][k]->GetYaxis()->SetRangeUser(0, 72.);
2570  // hist_SumADC[sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
2571  if (sub==1) {cHB->Modified(); cHB->Update();}
2572  if (sub==2) {cHE->Modified(); cHE->Update();}
2573  if (sub==3) {cONE->Modified();cONE->Update();}
2574  if (sub==4) {cHB->Modified(); cHB->Update();}
2575  }//end depth
2576  if (sub==1) {cHB->Print("Hist_SumADC_HB.png"); cHB->Clear();}
2577  if (sub==2) {cHE->Print("Hist_SumADC_HE.png"); cHE->Clear();}
2578  if (sub==3) {cONE->Print("Hist_SumADC_HO.png"); cONE->Clear();}
2579  if (sub==4) {cHB->Print("Hist_SumADC_HF.png"); cHB->Clear();}
2580  }// end sub
2581 
2582 
2583  for (int sub=1;sub<=4;sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
2584  if (sub==1) cHB->Divide(2,1);
2585  if (sub==2) cHE->Divide(3,1);
2586  if (sub==3) cONE->Divide(1,1);
2587  if (sub==4) cHB->Divide(2,1);
2588  int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
2589  int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
2590  for (int k=k_min[sub];k<=k_max[sub];k++) { //Depths
2591  if (sub==1) cHB->cd(k);
2592  if (sub==2) cHE->cd(k);
2593  if (sub==3) cONE->cd(k-3);
2594  if (sub==4) cHB->cd(k);
2595  gPad->SetGridy();
2596  gPad->SetGridx();
2597  gPad->SetLogy();
2598  hist_SumADC0[sub][k]->SetXTitle("ADC sum \b");
2599  hist_SumADC0[sub][k]->SetYTitle("Number of channels-events \b");
2600  if (sub==1) sprintf(str,"HB, Depth%d \b", k);
2601  if (sub==2) sprintf(str,"HE, Depth%d \b", k);
2602  if (sub==3) sprintf(str,"HO, Depth%d \b", k);
2603  if (sub==4) sprintf(str,"HF, Depth%d \b", k);
2604  hist_SumADC0[sub][k]->SetTitle(str);
2605  hist_SumADC0[sub][k]->Draw("");
2606  // hist_SumADC0[sub][k]->GetYaxis()->SetRangeUser(0, 72.);
2607  // hist_SumADC0[sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
2608  if (sub==1) {cHB->Modified(); cHB->Update();}
2609  if (sub==2) {cHE->Modified(); cHE->Update();}
2610  if (sub==3) {cONE->Modified();cONE->Update();}
2611  if (sub==4) {cHB->Modified(); cHB->Update();}
2612  }//end depth
2613  if (sub==1) {cHB->Print("Hist_SumADC_HB0.png"); cHB->Clear();}
2614  if (sub==2) {cHE->Print("Hist_SumADC_HE0.png"); cHE->Clear();}
2615  if (sub==3) {cONE->Print("Hist_SumADC_HO0.png"); cONE->Clear();}
2616  if (sub==4) {cHB->Print("Hist_SumADC_HF0.png"); cHB->Clear();}
2617  }// end sub
2618 
2619  for (int sub=1;sub<=4;sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
2620  if (sub==1) cHB->Divide(2,1);
2621  if (sub==2) cHE->Divide(3,1);
2622  if (sub==3) cONE->Divide(1,1);
2623  if (sub==4) cHB->Divide(2,1);
2624  int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
2625  int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
2626  for (int k=k_min[sub];k<=k_max[sub];k++) { //Depths
2627  if (sub==1) cHB->cd(k);
2628  if (sub==2) cHE->cd(k);
2629  if (sub==3) cONE->cd(k-3);
2630  if (sub==4) cHB->cd(k);
2631  gPad->SetGridy();
2632  gPad->SetGridx();
2633  gPad->SetLogy();
2634  hist_SumADC1[sub][k]->SetXTitle("ADC sum \b");
2635  hist_SumADC1[sub][k]->SetYTitle("Number of channels-events \b");
2636  if (sub==1) sprintf(str,"HB, Depth%d \b", k);
2637  if (sub==2) sprintf(str,"HE, Depth%d \b", k);
2638  if (sub==3) sprintf(str,"HO, Depth%d \b", k);
2639  if (sub==4) sprintf(str,"HF, Depth%d \b", k);
2640  hist_SumADC1[sub][k]->SetTitle(str);
2641  hist_SumADC1[sub][k]->Draw("");
2642  // hist_SumADC1[sub][k]->GetYaxis()->SetRangeUser(0, 72.);
2643  // hist_SumADC1[sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
2644  if (sub==1) {cHB->Modified(); cHB->Update();}
2645  if (sub==2) {cHE->Modified(); cHE->Update();}
2646  if (sub==3) {cONE->Modified();cONE->Update();}
2647  if (sub==4) {cHB->Modified(); cHB->Update();}
2648  }//end depth
2649  if (sub==1) {cHB->Print("Hist_SumADC_HB1.png"); cHB->Clear();}
2650  if (sub==2) {cHE->Print("Hist_SumADC_HE1.png"); cHE->Clear();}
2651  if (sub==3) {cONE->Print("Hist_SumADC_HO1.png"); cONE->Clear();}
2652  if (sub==4) {cHB->Print("Hist_SumADC_HF1.png"); cHB->Clear();}
2653  }// end sub
2654 
2655 */
2656 
2662 
2663  /*
2664  depth=5 all
2665  i=1-82 in initial histo
2666  j=i-1 in massives
2667 
2668  j= 13 23 (11) 12 25 (!!!)
2669  j-41 in histo
2670  -28 -18 (11) -29 -16
2671 
2672  j= 59 69 (11) 57 70 (!!!)
2673  j-41 in histo
2674  18 28 (11) 16 29
2675  */
2676 
2677  const int nsub = 4;
2678  const int neta = 82;
2679  const int nphi = 72;
2680  int njeta = neta;
2681  int njphi = nphi;
2682  //const int ndepth = 7;
2683  int ndepth;
2687 
2692 
2696  // int k_max[5]={0,4,7,4,4}; // maximum depth for each subdet
2697  //ndepth = k_max[5];
2698  ndepth = 4;
2699  double adigiHB[ndepth][njeta][njphi];
2700  double digivarianceHB[ndepth][njeta][njphi];
2701  // RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR: Digi HB
2702  TH2F *amplitudechannel1HB1 = (TH2F *)dir->FindObjectAny("h_amplitudechannel1_HB1");
2703  TH2F *amplitudechannel0HB1 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HB1");
2704  TH2F *amplitudechannelHB1 = (TH2F *)amplitudechannel1HB1->Clone("amplitudechannelHB1");
2705  amplitudechannelHB1->Divide(amplitudechannel1HB1, amplitudechannel0HB1, 1, 1, "B");
2706  TH2F *amplitudechannel1HB2 = (TH2F *)dir->FindObjectAny("h_amplitudechannel1_HB2");
2707  TH2F *amplitudechannel0HB2 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HB2");
2708  TH2F *amplitudechannelHB2 = (TH2F *)amplitudechannel1HB2->Clone("amplitudechannelHB2");
2709  amplitudechannelHB2->Divide(amplitudechannel1HB2, amplitudechannel0HB2, 1, 1, "B");
2710  TH2F *amplitudechannel1HB3 = (TH2F *)dir->FindObjectAny("h_amplitudechannel1_HB3");
2711  TH2F *amplitudechannel0HB3 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HB3");
2712  TH2F *amplitudechannelHB3 = (TH2F *)amplitudechannel1HB3->Clone("amplitudechannelHB3");
2713  amplitudechannelHB3->Divide(amplitudechannel1HB3, amplitudechannel0HB3, 1, 1, "B");
2714  TH2F *amplitudechannel1HB4 = (TH2F *)dir->FindObjectAny("h_amplitudechannel1_HB4");
2715  TH2F *amplitudechannel0HB4 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HB4");
2716  TH2F *amplitudechannelHB4 = (TH2F *)amplitudechannel1HB4->Clone("amplitudechannelHB4");
2717  amplitudechannelHB4->Divide(amplitudechannel1HB4, amplitudechannel0HB4, 1, 1, "B");
2718  for (int jeta = 0; jeta < njeta; jeta++) {
2719  //====================================================================== PHI normalization & put R into massive adigiHB
2720  //preparation for PHI normalization:
2721  double sumdigiHB0 = 0;
2722  int nsumdigiHB0 = 0;
2723  double sumdigiHB1 = 0;
2724  int nsumdigiHB1 = 0;
2725  double sumdigiHB2 = 0;
2726  int nsumdigiHB2 = 0;
2727  double sumdigiHB3 = 0;
2728  int nsumdigiHB3 = 0;
2729  for (int jphi = 0; jphi < njphi; jphi++) {
2730  adigiHB[0][jeta][jphi] = amplitudechannelHB1->GetBinContent(jeta + 1, jphi + 1);
2731  adigiHB[1][jeta][jphi] = amplitudechannelHB2->GetBinContent(jeta + 1, jphi + 1);
2732  adigiHB[2][jeta][jphi] = amplitudechannelHB3->GetBinContent(jeta + 1, jphi + 1);
2733  adigiHB[3][jeta][jphi] = amplitudechannelHB4->GetBinContent(jeta + 1, jphi + 1);
2734  if (adigiHB[0][jeta][jphi] > 0.) {
2735  sumdigiHB0 += adigiHB[0][jeta][jphi];
2736  ++nsumdigiHB0;
2737  }
2738  if (adigiHB[1][jeta][jphi] > 0.) {
2739  sumdigiHB1 += adigiHB[1][jeta][jphi];
2740  ++nsumdigiHB1;
2741  }
2742  if (adigiHB[2][jeta][jphi] > 0.) {
2743  sumdigiHB2 += adigiHB[2][jeta][jphi];
2744  ++nsumdigiHB2;
2745  }
2746  if (adigiHB[3][jeta][jphi] > 0.) {
2747  sumdigiHB3 += adigiHB[3][jeta][jphi];
2748  ++nsumdigiHB3;
2749  }
2750  } // phi
2751  // PHI normalization:
2752  for (int jphi = 0; jphi < njphi; jphi++) {
2753  if (adigiHB[0][jeta][jphi] > 0.)
2754  adigiHB[0][jeta][jphi] /= (sumdigiHB0 / nsumdigiHB0);
2755  if (adigiHB[1][jeta][jphi] > 0.)
2756  adigiHB[1][jeta][jphi] /= (sumdigiHB1 / nsumdigiHB1);
2757  if (adigiHB[2][jeta][jphi] > 0.)
2758  adigiHB[2][jeta][jphi] /= (sumdigiHB2 / nsumdigiHB2);
2759  if (adigiHB[3][jeta][jphi] > 0.)
2760  adigiHB[3][jeta][jphi] /= (sumdigiHB3 / nsumdigiHB3);
2761  } // phi
2762  } //eta
2763  //------------------------ 2D-eta/phi-plot: R, averaged over depthfs
2764  //======================================================================
2765  //======================================================================
2766  //cout<<" R2D-eta/phi-plot: R, averaged over depthfs *****" <<endl;
2767  c1x0->Clear();
2769  c1x0->Divide(1, 1);
2770  c1x0->cd(1);
2771  TH2F *GefzRdigiHB42D = new TH2F("GefzRdigiHB42D", "", neta, -41., 41., nphi, 0., 72.);
2772  TH2F *GefzRdigiHB42D0 = new TH2F("GefzRdigiHB42D0", "", neta, -41., 41., nphi, 0., 72.);
2773  TH2F *GefzRdigiHB42DF = (TH2F *)GefzRdigiHB42D0->Clone("GefzRdigiHB42DF");
2774  for (int i = 0; i < ndepth; i++) {
2775  for (int jeta = 0; jeta < neta; jeta++) {
2776  for (int jphi = 0; jphi < nphi; jphi++) {
2777  double ccc1 = adigiHB[i][jeta][jphi];
2778  int k2plot = jeta - 41;
2779  int kkk = k2plot; //if(k2plot >0 ) kkk=k2plot+1; //-41 +41 !=0
2780  if (ccc1 != 0.) {
2781  GefzRdigiHB42D->Fill(kkk, jphi, ccc1);
2782  GefzRdigiHB42D0->Fill(kkk, jphi, 1.);
2783  }
2784  }
2785  }
2786  }
2787  GefzRdigiHB42DF->Divide(GefzRdigiHB42D, GefzRdigiHB42D0, 1, 1, "B"); // average A
2788  gPad->SetGridy();
2789  gPad->SetGridx(); // gPad->SetLogz();
2790  GefzRdigiHB42DF->SetMarkerStyle(20);
2791  GefzRdigiHB42DF->SetMarkerSize(0.4);
2792  GefzRdigiHB42DF->GetZaxis()->SetLabelSize(0.08);
2793  GefzRdigiHB42DF->SetXTitle("<R>_depth #eta \b");
2794  GefzRdigiHB42DF->SetYTitle(" #phi \b");
2795  GefzRdigiHB42DF->SetZTitle("<R>_depth \b");
2796  GefzRdigiHB42DF->SetMarkerColor(2);
2797  GefzRdigiHB42DF->SetLineColor(
2798  0); // GefzRdigiHB42DF->SetMaximum(1.000); // GefzRdigiHB42DF->SetMinimum(1.0);
2799  GefzRdigiHB42DF->Draw("COLZ");
2801  c1x0->Update();
2802  c1x0->Print("RdigiGeneralD2PhiSymmetryHB.png");
2803  c1x0->Clear();
2804  // clean-up
2805  if (GefzRdigiHB42D)
2806  delete GefzRdigiHB42D;
2807  if (GefzRdigiHB42D0)
2808  delete GefzRdigiHB42D0;
2809  if (GefzRdigiHB42DF)
2810  delete GefzRdigiHB42DF;
2811  //====================================================================== 1D plot: R vs phi , averaged over depthfs & eta
2812  //======================================================================
2813  //cout<<" 1D plot: R vs phi , averaged over depthfs & eta *****" <<endl;
2814  c1x1->Clear();
2816  c1x1->Divide(1, 1);
2817  c1x1->cd(1);
2818  TH1F *GefzRdigiHB41D = new TH1F("GefzRdigiHB41D", "", nphi, 0., 72.);
2819  TH1F *GefzRdigiHB41D0 = new TH1F("GefzRdigiHB41D0", "", nphi, 0., 72.);
2820  TH1F *GefzRdigiHB41DF = (TH1F *)GefzRdigiHB41D0->Clone("GefzRdigiHB41DF");
2821  for (int jphi = 0; jphi < nphi; jphi++) {
2822  for (int jeta = 0; jeta < neta; jeta++) {
2823  for (int i = 0; i < ndepth; i++) {
2824  double ccc1 = adigiHB[i][jeta][jphi];
2825  if (ccc1 != 0.) {
2826  GefzRdigiHB41D->Fill(jphi, ccc1);
2827  GefzRdigiHB41D0->Fill(jphi, 1.);
2828  }
2829  }
2830  }
2831  }
2832  GefzRdigiHB41DF->Divide(GefzRdigiHB41D, GefzRdigiHB41D0, 1, 1, "B"); // R averaged over depthfs & eta
2833  GefzRdigiHB41D0->Sumw2();
2834  // for (int jphi=1;jphi<73;jphi++) {GefzRdigiHB41DF->SetBinError(jphi,0.01);}
2835  gPad->SetGridy();
2836  gPad->SetGridx(); // gPad->SetLogz();
2837  GefzRdigiHB41DF->SetMarkerStyle(20);
2838  GefzRdigiHB41DF->SetMarkerSize(1.4);
2839  GefzRdigiHB41DF->GetZaxis()->SetLabelSize(0.08);
2840  GefzRdigiHB41DF->SetXTitle("#phi \b");
2841  GefzRdigiHB41DF->SetYTitle(" <R> \b");
2842  GefzRdigiHB41DF->SetZTitle("<R>_PHI - AllDepthfs \b");
2843  GefzRdigiHB41DF->SetMarkerColor(4);
2844  GefzRdigiHB41DF->SetLineColor(
2845  4); // GefzRdigiHB41DF->SetMinimum(0.8); // GefzRdigiHB41DF->SetMaximum(1.000);
2846  GefzRdigiHB41DF->Draw("Error");
2848  c1x1->Update();
2849  c1x1->Print("RdigiGeneralD1PhiSymmetryHB.png");
2850  c1x1->Clear();
2851  // clean-up
2852  if (GefzRdigiHB41D)
2853  delete GefzRdigiHB41D;
2854  if (GefzRdigiHB41D0)
2855  delete GefzRdigiHB41D0;
2856  if (GefzRdigiHB41DF)
2857  delete GefzRdigiHB41DF;
2858  //========================================================================================== 4
2859  //======================================================================
2860  //======================================================================1D plot: R vs phi , different eta, depth=1
2861  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
2862  c3x5->Clear();
2864  c3x5->Divide(4, 4);
2865  c3x5->cd(1);
2866  int kcountHBpositivedirectionDigi1 = 1;
2867  TH1F *h2CeffHBpositivedirectionDigi1 = new TH1F("h2CeffHBpositivedirectionDigi1", "", nphi, 0., 72.);
2868  for (int jeta = 0; jeta < njeta; jeta++) {
2869  // positivedirectionDigi:
2870  if (jeta - 41 >= 0) {
2871  // for (int i=0;i<ndepth;i++) {
2872  // depth=1
2873  for (int i = 0; i < 1; i++) {
2874  TH1F *HBpositivedirectionDigi1 = (TH1F *)h2CeffHBpositivedirectionDigi1->Clone("twod1");
2875  float ccctest = 0; // to avoid empty massive elements
2876  for (int jphi = 0; jphi < nphi; jphi++) {
2877  double ccc1 = adigiHB[i][jeta][jphi];
2878  if (ccc1 != 0.) {
2879  HBpositivedirectionDigi1->Fill(jphi, ccc1);
2880  ccctest = 1.; //HBpositivedirectionDigi1->SetBinError(i,0.01);
2881  }
2882  } // for jphi
2883  if (ccctest > 0.) {
2884  // cout<<"444 kcountHBpositivedirectionDigi1 = "<<kcountHBpositivedirectionDigi1 <<" jeta-41= "<< jeta-41 <<endl;
2885  c3x5->cd(kcountHBpositivedirectionDigi1);
2886  HBpositivedirectionDigi1->SetMarkerStyle(20);
2887  HBpositivedirectionDigi1->SetMarkerSize(0.4);
2888  HBpositivedirectionDigi1->GetYaxis()->SetLabelSize(0.04);
2889  HBpositivedirectionDigi1->SetXTitle("HBpositivedirectionDigi1 \b");
2890  HBpositivedirectionDigi1->SetMarkerColor(2);
2891  HBpositivedirectionDigi1->SetLineColor(0);
2892  gPad->SetGridy();
2893  gPad->SetGridx();
2894  // gPad->SetLogy();
2895  if (kcountHBpositivedirectionDigi1 == 1)
2896  HBpositivedirectionDigi1->SetXTitle("R for HB+ jeta = 0; depth = 1 \b");
2897  if (kcountHBpositivedirectionDigi1 == 2)
2898  HBpositivedirectionDigi1->SetXTitle("R for HB+ jeta = 1; depth = 1 \b");
2899  if (kcountHBpositivedirectionDigi1 == 3)
2900  HBpositivedirectionDigi1->SetXTitle("R for HB+ jeta = 2; depth = 1 \b");
2901  if (kcountHBpositivedirectionDigi1 == 4)
2902  HBpositivedirectionDigi1->SetXTitle("R for HB+ jeta = 3; depth = 1 \b");
2903  if (kcountHBpositivedirectionDigi1 == 5)
2904  HBpositivedirectionDigi1->SetXTitle("R for HB+ jeta = 4; depth = 1 \b");
2905  if (kcountHBpositivedirectionDigi1 == 6)
2906  HBpositivedirectionDigi1->SetXTitle("R for HB+ jeta = 5; depth = 1 \b");
2907  if (kcountHBpositivedirectionDigi1 == 7)
2908  HBpositivedirectionDigi1->SetXTitle("R for HB+ jeta = 6; depth = 1 \b");
2909  if (kcountHBpositivedirectionDigi1 == 8)
2910  HBpositivedirectionDigi1->SetXTitle("R for HB+ jeta = 7; depth = 1 \b");
2911  if (kcountHBpositivedirectionDigi1 == 9)
2912  HBpositivedirectionDigi1->SetXTitle("R for HB+ jeta = 8; depth = 1 \b");
2913  if (kcountHBpositivedirectionDigi1 == 10)
2914  HBpositivedirectionDigi1->SetXTitle("R for HB+ jeta = 9; depth = 1 \b");
2915  if (kcountHBpositivedirectionDigi1 == 11)
2916  HBpositivedirectionDigi1->SetXTitle("R for HB+ jeta = 10; depth = 1 \b");
2917  if (kcountHBpositivedirectionDigi1 == 12)
2918  HBpositivedirectionDigi1->SetXTitle("R for HB+ jeta = 11; depth = 1 \b");
2919  if (kcountHBpositivedirectionDigi1 == 13)
2920  HBpositivedirectionDigi1->SetXTitle("R for HB+ jeta = 12; depth = 1 \b");
2921  if (kcountHBpositivedirectionDigi1 == 14)
2922  HBpositivedirectionDigi1->SetXTitle("R for HB+ jeta = 13; depth = 1 \b");
2923  if (kcountHBpositivedirectionDigi1 == 15)
2924  HBpositivedirectionDigi1->SetXTitle("R for HB+ jeta = 14; depth = 1 \b");
2925  if (kcountHBpositivedirectionDigi1 == 16)
2926  HBpositivedirectionDigi1->SetXTitle("R for HB+ jeta = 15; depth = 1 \b");
2927  HBpositivedirectionDigi1->Draw("Error");
2928  kcountHBpositivedirectionDigi1++;
2929  if (kcountHBpositivedirectionDigi1 > 16)
2930  break; //
2931  } //ccctest>0
2932 
2933  } // for i
2934  } //if(jeta-41 >= 0)
2935  } //for jeta
2937  c3x5->Update();
2938  c3x5->Print("RdigiPositiveDirectionhistD1PhiSymmetryDepth1HB.png");
2939  c3x5->Clear();
2940  // clean-up
2941  if (h2CeffHBpositivedirectionDigi1)
2942  delete h2CeffHBpositivedirectionDigi1;
2943 
2944  //========================================================================================== 5
2945  //======================================================================
2946  //======================================================================1D plot: R vs phi , different eta, depth=2
2947  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
2948  c3x5->Clear();
2950  c3x5->Divide(4, 4);
2951  c3x5->cd(1);
2952  int kcountHBpositivedirectionDigi2 = 1;
2953  TH1F *h2CeffHBpositivedirectionDigi2 = new TH1F("h2CeffHBpositivedirectionDigi2", "", nphi, 0., 72.);
2954  for (int jeta = 0; jeta < njeta; jeta++) {
2955  // positivedirectionDigi:
2956  if (jeta - 41 >= 0) {
2957  // for (int i=0;i<ndepth;i++) {
2958  // depth=2
2959  for (int i = 1; i < 2; i++) {
2960  TH1F *HBpositivedirectionDigi2 = (TH1F *)h2CeffHBpositivedirectionDigi2->Clone("twod1");
2961  float ccctest = 0; // to avoid empty massive elements
2962  for (int jphi = 0; jphi < nphi; jphi++) {
2963  double ccc1 = adigiHB[i][jeta][jphi];
2964  if (ccc1 != 0.) {
2965  HBpositivedirectionDigi2->Fill(jphi, ccc1);
2966  ccctest = 1.; //HBpositivedirectionDigi2->SetBinError(i,0.01);
2967  }
2968  } // for jphi
2969  if (ccctest > 0.) {
2970  //cout<<"555 kcountHBpositivedirectionDigi2 = "<<kcountHBpositivedirectionDigi2 <<" jeta-41= "<< jeta-41 <<endl;
2971  c3x5->cd(kcountHBpositivedirectionDigi2);
2972  HBpositivedirectionDigi2->SetMarkerStyle(20);
2973  HBpositivedirectionDigi2->SetMarkerSize(0.4);
2974  HBpositivedirectionDigi2->GetYaxis()->SetLabelSize(0.04);
2975  HBpositivedirectionDigi2->SetXTitle("HBpositivedirectionDigi2 \b");
2976  HBpositivedirectionDigi2->SetMarkerColor(2);
2977  HBpositivedirectionDigi2->SetLineColor(0);
2978  gPad->SetGridy();
2979  gPad->SetGridx();
2980  // gPad->SetLogy();
2981  if (kcountHBpositivedirectionDigi2 == 1)
2982  HBpositivedirectionDigi2->SetXTitle("R for HB+ jeta = 0; depth = 2 \b");
2983  if (kcountHBpositivedirectionDigi2 == 2)
2984  HBpositivedirectionDigi2->SetXTitle("R for HB+ jeta = 1; depth = 2 \b");
2985  if (kcountHBpositivedirectionDigi2 == 3)
2986  HBpositivedirectionDigi2->SetXTitle("R for HB+ jeta = 2; depth = 2 \b");
2987  if (kcountHBpositivedirectionDigi2 == 4)
2988  HBpositivedirectionDigi2->SetXTitle("R for HB+ jeta = 3; depth = 2 \b");
2989  if (kcountHBpositivedirectionDigi2 == 5)
2990  HBpositivedirectionDigi2->SetXTitle("R for HB+ jeta = 4; depth = 2 \b");
2991  if (kcountHBpositivedirectionDigi2 == 6)
2992  HBpositivedirectionDigi2->SetXTitle("R for HB+ jeta = 5; depth = 2 \b");
2993  if (kcountHBpositivedirectionDigi2 == 7)
2994  HBpositivedirectionDigi2->SetXTitle("R for HB+ jeta = 6; depth = 2 \b");
2995  if (kcountHBpositivedirectionDigi2 == 8)
2996  HBpositivedirectionDigi2->SetXTitle("R for HB+ jeta = 7; depth = 2 \b");
2997  if (kcountHBpositivedirectionDigi2 == 9)
2998  HBpositivedirectionDigi2->SetXTitle("R for HB+ jeta = 8; depth = 2 \b");
2999  if (kcountHBpositivedirectionDigi2 == 10)
3000  HBpositivedirectionDigi2->SetXTitle("R for HB+ jeta = 9; depth = 2 \b");
3001  if (kcountHBpositivedirectionDigi2 == 11)
3002  HBpositivedirectionDigi2->SetXTitle("R for HB+ jeta = 10; depth = 2 \b");
3003  if (kcountHBpositivedirectionDigi2 == 12)
3004  HBpositivedirectionDigi2->SetXTitle("R for HB+ jeta = 11; depth = 2 \b");
3005  if (kcountHBpositivedirectionDigi2 == 13)
3006  HBpositivedirectionDigi2->SetXTitle("R for HB+ jeta = 12; depth = 2 \b");
3007  if (kcountHBpositivedirectionDigi2 == 14)
3008  HBpositivedirectionDigi2->SetXTitle("R for HB+ jeta = 13; depth = 2 \b");
3009  if (kcountHBpositivedirectionDigi2 == 15)
3010  HBpositivedirectionDigi2->SetXTitle("R for HB+ jeta = 14; depth = 2 \b");
3011  if (kcountHBpositivedirectionDigi2 == 16)
3012  HBpositivedirectionDigi2->SetXTitle("R for HB+ jeta = 15; depth = 2 \b");
3013  HBpositivedirectionDigi2->Draw("Error");
3014  kcountHBpositivedirectionDigi2++;
3015  if (kcountHBpositivedirectionDigi2 > 16)
3016  break; // 4x6 = 24
3017  } //ccctest>0
3018 
3019  } // for i
3020  } //if(jeta-41 >= 0)
3021  } //for jeta
3023  c3x5->Update();
3024  c3x5->Print("RdigiPositiveDirectionhistD1PhiSymmetryDepth2HB.png");
3025  c3x5->Clear();
3026  // clean-up
3027  if (h2CeffHBpositivedirectionDigi2)
3028  delete h2CeffHBpositivedirectionDigi2;
3029  //========================================================================================== 6
3030  //======================================================================
3031  //======================================================================1D plot: R vs phi , different eta, depth=3
3032  //cout<<" 1D plot: R vs phi , different eta, depth=3 *****" <<endl;
3033  c3x5->Clear();
3035  c3x5->Divide(4, 4);
3036  c3x5->cd(1);
3037  int kcountHBpositivedirectionDigi3 = 1;
3038  TH1F *h2CeffHBpositivedirectionDigi3 = new TH1F("h2CeffHBpositivedirectionDigi3", "", nphi, 0., 72.);
3039  for (int jeta = 0; jeta < njeta; jeta++) {
3040  // positivedirectionDigi:
3041  if (jeta - 41 >= 0) {
3042  // for (int i=0;i<ndepth;i++) {
3043  // depth=3
3044  for (int i = 2; i < 3; i++) {
3045  TH1F *HBpositivedirectionDigi3 = (TH1F *)h2CeffHBpositivedirectionDigi3->Clone("twod1");
3046  float ccctest = 0; // to avoid empty massive elements
3047  for (int jphi = 0; jphi < nphi; jphi++) {
3048  double ccc1 = adigiHB[i][jeta][jphi];
3049  if (ccc1 != 0.) {
3050  HBpositivedirectionDigi3->Fill(jphi, ccc1);
3051  ccctest = 1.; //HBpositivedirectionDigi3->SetBinError(i,0.01);
3052  }
3053  } // for jphi
3054  if (ccctest > 0.) {
3055  //cout<<"666 kcountHBpositivedirectionDigi3 = "<<kcountHBpositivedirectionDigi3 <<" jeta-41= "<< jeta-41 <<endl;
3056  c3x5->cd(kcountHBpositivedirectionDigi3);
3057  HBpositivedirectionDigi3->SetMarkerStyle(20);
3058  HBpositivedirectionDigi3->SetMarkerSize(0.4);
3059  HBpositivedirectionDigi3->GetYaxis()->SetLabelSize(0.04);
3060  HBpositivedirectionDigi3->SetXTitle("HBpositivedirectionDigi3 \b");
3061  HBpositivedirectionDigi3->SetMarkerColor(2);
3062  HBpositivedirectionDigi3->SetLineColor(0);
3063  gPad->SetGridy();
3064  gPad->SetGridx();
3065  // gPad->SetLogy();
3066  if (kcountHBpositivedirectionDigi3 == 1)
3067  HBpositivedirectionDigi3->SetXTitle("R for HB+ jeta = 0; depth = 3 \b");
3068  if (kcountHBpositivedirectionDigi3 == 2)
3069  HBpositivedirectionDigi3->SetXTitle("R for HB+ jeta = 1; depth = 3 \b");
3070  if (kcountHBpositivedirectionDigi3 == 3)
3071  HBpositivedirectionDigi3->SetXTitle("R for HB+ jeta = 2; depth = 3 \b");
3072  if (kcountHBpositivedirectionDigi3 == 4)
3073  HBpositivedirectionDigi3->SetXTitle("R for HB+ jeta = 3; depth = 3 \b");
3074  if (kcountHBpositivedirectionDigi3 == 5)
3075  HBpositivedirectionDigi3->SetXTitle("R for HB+ jeta = 4; depth = 3 \b");
3076  if (kcountHBpositivedirectionDigi3 == 6)
3077  HBpositivedirectionDigi3->SetXTitle("R for HB+ jeta = 5; depth = 3 \b");
3078  if (kcountHBpositivedirectionDigi3 == 7)
3079  HBpositivedirectionDigi3->SetXTitle("R for HB+ jeta = 6; depth = 3 \b");
3080  if (kcountHBpositivedirectionDigi3 == 8)
3081  HBpositivedirectionDigi3->SetXTitle("R for HB+ jeta = 7; depth = 3 \b");
3082  if (kcountHBpositivedirectionDigi3 == 9)
3083  HBpositivedirectionDigi3->SetXTitle("R for HB+ jeta = 8; depth = 3 \b");
3084  if (kcountHBpositivedirectionDigi3 == 10)
3085  HBpositivedirectionDigi3->SetXTitle("R for HB+ jeta = 9; depth = 3 \b");
3086  if (kcountHBpositivedirectionDigi3 == 11)
3087  HBpositivedirectionDigi3->SetXTitle("R for HB+ jeta = 0; depth = 3 \b");
3088  if (kcountHBpositivedirectionDigi3 == 12)
3089  HBpositivedirectionDigi3->SetXTitle("R for HB+ jeta = 11; depth = 3 \b");
3090  if (kcountHBpositivedirectionDigi3 == 13)
3091  HBpositivedirectionDigi3->SetXTitle("R for HB+ jeta = 12; depth = 3 \b");
3092  if (kcountHBpositivedirectionDigi3 == 14)
3093  HBpositivedirectionDigi3->SetXTitle("R for HB+ jeta = 13; depth = 3 \b");
3094  if (kcountHBpositivedirectionDigi3 == 15)
3095  HBpositivedirectionDigi3->SetXTitle("R for HB+ jeta = 14; depth = 3 \b");
3096  if (kcountHBpositivedirectionDigi3 == 16)
3097  HBpositivedirectionDigi3->SetXTitle("R for HB+ jeta = 15; depth = 3 \b");
3098  HBpositivedirectionDigi3->Draw("Error");
3099  kcountHBpositivedirectionDigi3++;
3100  if (kcountHBpositivedirectionDigi3 > 16)
3101  break; // 4x6 = 24
3102  } //ccctest>0
3103 
3104  } // for i
3105  } //if(jeta-41 >= 0)
3106  } //for jeta
3108  c3x5->Update();
3109  c3x5->Print("RdigiPositiveDirectionhistD1PhiSymmetryDepth3HB.png");
3110  c3x5->Clear();
3111  // clean-up
3112  if (h2CeffHBpositivedirectionDigi3)
3113  delete h2CeffHBpositivedirectionDigi3;
3114  //========================================================================================== 7
3115  //======================================================================
3116  //======================================================================1D plot: R vs phi , different eta, depth=4
3117  //cout<<" 1D plot: R vs phi , different eta, depth=4 *****" <<endl;
3118  c3x5->Clear();
3120  c3x5->Divide(4, 4);
3121  c3x5->cd(1);
3122  int kcountHBpositivedirectionDigi4 = 1;
3123  TH1F *h2CeffHBpositivedirectionDigi4 = new TH1F("h2CeffHBpositivedirectionDigi4", "", nphi, 0., 72.);
3124 
3125  for (int jeta = 0; jeta < njeta; jeta++) {
3126  // positivedirectionDigi:
3127  if (jeta - 41 >= 0) {
3128  // for (int i=0;i<ndepth;i++) {
3129  // depth=4
3130  for (int i = 3; i < 4; i++) {
3131  TH1F *HBpositivedirectionDigi4 = (TH1F *)h2CeffHBpositivedirectionDigi4->Clone("twod1");
3132 
3133  float ccctest = 0; // to avoid empty massive elements
3134  for (int jphi = 0; jphi < nphi; jphi++) {
3135  double ccc1 = adigiHB[i][jeta][jphi];
3136  if (ccc1 != 0.) {
3137  HBpositivedirectionDigi4->Fill(jphi, ccc1);
3138  ccctest = 1.; //HBpositivedirectionDigi4->SetBinError(i,0.01);
3139  }
3140  } // for jphi
3141  if (ccctest > 0.) {
3142  //cout<<"777 kcountHBpositivedirectionDigi4 = "<<kcountHBpositivedirectionDigi4 <<" jeta-41= "<< jeta-41 <<endl;
3143  c3x5->cd(kcountHBpositivedirectionDigi4);
3144  HBpositivedirectionDigi4->SetMarkerStyle(20);
3145  HBpositivedirectionDigi4->SetMarkerSize(0.4);
3146  HBpositivedirectionDigi4->GetYaxis()->SetLabelSize(0.04);
3147  HBpositivedirectionDigi4->SetXTitle("HBpositivedirectionDigi4 \b");
3148  HBpositivedirectionDigi4->SetMarkerColor(2);
3149  HBpositivedirectionDigi4->SetLineColor(0);
3150  gPad->SetGridy();
3151  gPad->SetGridx();
3152  // gPad->SetLogy();
3153  if (kcountHBpositivedirectionDigi4 == 1)
3154  HBpositivedirectionDigi4->SetXTitle("R for HB+ jeta = 0; depth = 4 \b");
3155  if (kcountHBpositivedirectionDigi4 == 2)
3156  HBpositivedirectionDigi4->SetXTitle("R for HB+ jeta = 1; depth = 4 \b");
3157  if (kcountHBpositivedirectionDigi4 == 3)
3158  HBpositivedirectionDigi4->SetXTitle("R for HB+ jeta = 2; depth = 4 \b");
3159  if (kcountHBpositivedirectionDigi4 == 4)
3160  HBpositivedirectionDigi4->SetXTitle("R for HB+ jeta = 3; depth = 4 \b");
3161  if (kcountHBpositivedirectionDigi4 == 5)
3162  HBpositivedirectionDigi4->SetXTitle("R for HB+ jeta = 4; depth = 4 \b");
3163  if (kcountHBpositivedirectionDigi4 == 6)
3164  HBpositivedirectionDigi4->SetXTitle("R for HB+ jeta = 5; depth = 4 \b");
3165  if (kcountHBpositivedirectionDigi4 == 7)
3166  HBpositivedirectionDigi4->SetXTitle("R for HB+ jeta = 6; depth = 4 \b");
3167  if (kcountHBpositivedirectionDigi4 == 8)
3168  HBpositivedirectionDigi4->SetXTitle("R for HB+ jeta = 7; depth = 4 \b");
3169  if (kcountHBpositivedirectionDigi4 == 9)
3170  HBpositivedirectionDigi4->SetXTitle("R for HB+ jeta = 8; depth = 4 \b");
3171  if (kcountHBpositivedirectionDigi4 == 10)
3172  HBpositivedirectionDigi4->SetXTitle("R for HB+ jeta = 9; depth = 4 \b");
3173  if (kcountHBpositivedirectionDigi4 == 11)
3174  HBpositivedirectionDigi4->SetXTitle("R for HB+ jeta = 10; depth = 4 \b");
3175  if (kcountHBpositivedirectionDigi4 == 12)
3176  HBpositivedirectionDigi4->SetXTitle("R for HB+ jeta = 11; depth = 4 \b");
3177  if (kcountHBpositivedirectionDigi4 == 13)
3178  HBpositivedirectionDigi4->SetXTitle("R for HB+ jeta = 12; depth = 4 \b");
3179  if (kcountHBpositivedirectionDigi4 == 14)
3180  HBpositivedirectionDigi4->SetXTitle("R for HB+ jeta = 13; depth = 4 \b");
3181  if (kcountHBpositivedirectionDigi4 == 15)
3182  HBpositivedirectionDigi4->SetXTitle("R for HB+ jeta = 14; depth = 4 \b");
3183  if (kcountHBpositivedirectionDigi4 == 16)
3184  HBpositivedirectionDigi4->SetXTitle("R for HB+ jeta = 15; depth = 4 \b");
3185  HBpositivedirectionDigi4->Draw("Error");
3186  kcountHBpositivedirectionDigi4++;
3187  if (kcountHBpositivedirectionDigi4 > 16)
3188  break; // 4x6 = 24
3189  } //ccctest>0
3190 
3191  } // for i
3192  } //if(jeta-41 >= 0)
3193  } //for jeta
3195  c3x5->Update();
3196  c3x5->Print("RdigiPositiveDirectionhistD1PhiSymmetryDepth4HB.png");
3197  c3x5->Clear();
3198  // clean-up
3199  if (h2CeffHBpositivedirectionDigi4)
3200  delete h2CeffHBpositivedirectionDigi4;
3201 
3202  //========================================================================================== 1114
3203  //======================================================================
3204  //======================================================================1D plot: R vs phi , different eta, depth=1
3205  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
3206  c3x5->Clear();
3208  c3x5->Divide(4, 4);
3209  c3x5->cd(1);
3210  int kcountHBnegativedirectionDigi1 = 1;
3211  TH1F *h2CeffHBnegativedirectionDigi1 = new TH1F("h2CeffHBnegativedirectionDigi1", "", nphi, 0., 72.);
3212  for (int jeta = 0; jeta < njeta; jeta++) {
3213  // negativedirectionDigi:
3214  if (jeta - 41 < 0) {
3215  // for (int i=0;i<ndepth;i++) {
3216  // depth=1
3217  for (int i = 0; i < 1; i++) {
3218  TH1F *HBnegativedirectionDigi1 = (TH1F *)h2CeffHBnegativedirectionDigi1->Clone("twod1");
3219  float ccctest = 0; // to avoid empty massive elements
3220  for (int jphi = 0; jphi < nphi; jphi++) {
3221  double ccc1 = adigiHB[i][jeta][jphi];
3222  if (ccc1 != 0.) {
3223  HBnegativedirectionDigi1->Fill(jphi, ccc1);
3224  ccctest = 1.; //HBnegativedirectionDigi1->SetBinError(i,0.01);
3225  }
3226  } // for jphi
3227  if (ccctest > 0.) {
3228  // cout<<"444 kcountHBnegativedirectionDigi1 = "<<kcountHBnegativedirectionDigi1 <<" jeta-41= "<< jeta-41 <<endl;
3229  c3x5->cd(kcountHBnegativedirectionDigi1);
3230  HBnegativedirectionDigi1->SetMarkerStyle(20);
3231  HBnegativedirectionDigi1->SetMarkerSize(0.4);
3232  HBnegativedirectionDigi1->GetYaxis()->SetLabelSize(0.04);
3233  HBnegativedirectionDigi1->SetXTitle("HBnegativedirectionDigi1 \b");
3234  HBnegativedirectionDigi1->SetMarkerColor(2);
3235  HBnegativedirectionDigi1->SetLineColor(0);
3236  gPad->SetGridy();
3237  gPad->SetGridx();
3238  // gPad->SetLogy();
3239  if (kcountHBnegativedirectionDigi1 == 1)
3240  HBnegativedirectionDigi1->SetXTitle("R for HB- jeta = -16; depth = 1 \b");
3241  if (kcountHBnegativedirectionDigi1 == 2)
3242  HBnegativedirectionDigi1->SetXTitle("R for HB- jeta = -15; depth = 1 \b");
3243  if (kcountHBnegativedirectionDigi1 == 3)
3244  HBnegativedirectionDigi1->SetXTitle("R for HB- jeta = -14; depth = 1 \b");
3245  if (kcountHBnegativedirectionDigi1 == 4)
3246  HBnegativedirectionDigi1->SetXTitle("R for HB- jeta = -13; depth = 1 \b");
3247  if (kcountHBnegativedirectionDigi1 == 5)
3248  HBnegativedirectionDigi1->SetXTitle("R for HB- jeta = -12; depth = 1 \b");
3249  if (kcountHBnegativedirectionDigi1 == 6)
3250  HBnegativedirectionDigi1->SetXTitle("R for HB- jeta = -11; depth = 1 \b");
3251  if (kcountHBnegativedirectionDigi1 == 7)
3252  HBnegativedirectionDigi1->SetXTitle("R for HB- jeta = -10; depth = 1 \b");
3253  if (kcountHBnegativedirectionDigi1 == 8)
3254  HBnegativedirectionDigi1->SetXTitle("R for HB- jeta = -9; depth = 1 \b");
3255  if (kcountHBnegativedirectionDigi1 == 9)
3256  HBnegativedirectionDigi1->SetXTitle("R for HB- jeta = -8; depth = 1 \b");
3257  if (kcountHBnegativedirectionDigi1 == 10)
3258  HBnegativedirectionDigi1->SetXTitle("R for HB- jeta = -7; depth = 1 \b");
3259  if (kcountHBnegativedirectionDigi1 == 11)
3260  HBnegativedirectionDigi1->SetXTitle("R for HB- jeta = -6; depth = 1 \b");
3261  if (kcountHBnegativedirectionDigi1 == 12)
3262  HBnegativedirectionDigi1->SetXTitle("R for HB- jeta = -5; depth = 1 \b");
3263  if (kcountHBnegativedirectionDigi1 == 13)
3264  HBnegativedirectionDigi1->SetXTitle("R for HB- jeta = -4; depth = 1 \b");
3265  if (kcountHBnegativedirectionDigi1 == 14)
3266  HBnegativedirectionDigi1->SetXTitle("R for HB- jeta = -3; depth = 1 \b");
3267  if (kcountHBnegativedirectionDigi1 == 15)
3268  HBnegativedirectionDigi1->SetXTitle("R for HB- jeta = -2; depth = 1 \b");
3269  if (kcountHBnegativedirectionDigi1 == 16)
3270  HBnegativedirectionDigi1->SetXTitle("R for HB- jeta = -1; depth = 1 \b");
3271  HBnegativedirectionDigi1->Draw("Error");
3272  kcountHBnegativedirectionDigi1++;
3273  if (kcountHBnegativedirectionDigi1 > 16)
3274  break; //
3275  } //ccctest>0
3276 
3277  } // for i
3278  } //if(jeta-41 < 0 )
3279  } //for jeta
3281  c3x5->Update();
3282  c3x5->Print("RdigiNegativeDirectionhistD1PhiSymmetryDepth1HB.png");
3283  c3x5->Clear();
3284  // clean-up
3285  if (h2CeffHBnegativedirectionDigi1)
3286  delete h2CeffHBnegativedirectionDigi1;
3287 
3288  //========================================================================================== 1115
3289  //======================================================================
3290  //======================================================================1D plot: R vs phi , different eta, depth=2
3291  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
3292  c3x5->Clear();
3294  c3x5->Divide(4, 4);
3295  c3x5->cd(1);
3296  int kcountHBnegativedirectionDigi2 = 1;
3297  TH1F *h2CeffHBnegativedirectionDigi2 = new TH1F("h2CeffHBnegativedirectionDigi2", "", nphi, 0., 72.);
3298  for (int jeta = 0; jeta < njeta; jeta++) {
3299  // negativedirectionDigi:
3300  if (jeta - 41 < 0) {
3301  // for (int i=0;i<ndepth;i++) {
3302  // depth=2
3303  for (int i = 1; i < 2; i++) {
3304  TH1F *HBnegativedirectionDigi2 = (TH1F *)h2CeffHBnegativedirectionDigi2->Clone("twod1");
3305  float ccctest = 0; // to avoid empty massive elements
3306  for (int jphi = 0; jphi < nphi; jphi++) {
3307  double ccc1 = adigiHB[i][jeta][jphi];
3308  if (ccc1 != 0.) {
3309  HBnegativedirectionDigi2->Fill(jphi, ccc1);
3310  ccctest = 1.; //HBnegativedirectionDigi2->SetBinError(i,0.01);
3311  }
3312  } // for jphi
3313  if (ccctest > 0.) {
3314  //cout<<"555 kcountHBnegativedirectionDigi2 = "<<kcountHBnegativedirectionDigi2 <<" jeta-41= "<< jeta-41 <<endl;
3315  c3x5->cd(kcountHBnegativedirectionDigi2);
3316  HBnegativedirectionDigi2->SetMarkerStyle(20);
3317  HBnegativedirectionDigi2->SetMarkerSize(0.4);
3318  HBnegativedirectionDigi2->GetYaxis()->SetLabelSize(0.04);
3319  HBnegativedirectionDigi2->SetXTitle("HBnegativedirectionDigi2 \b");
3320  HBnegativedirectionDigi2->SetMarkerColor(2);
3321  HBnegativedirectionDigi2->SetLineColor(0);
3322  gPad->SetGridy();
3323  gPad->SetGridx();
3324  // gPad->SetLogy();
3325  if (kcountHBnegativedirectionDigi2 == 1)
3326  HBnegativedirectionDigi2->SetXTitle("R for HB- jeta = -16; depth = 2 \b");
3327  if (kcountHBnegativedirectionDigi2 == 2)
3328  HBnegativedirectionDigi2->SetXTitle("R for HB- jeta = -15; depth = 2 \b");
3329  if (kcountHBnegativedirectionDigi2 == 3)
3330  HBnegativedirectionDigi2->SetXTitle("R for HB- jeta = -14; depth = 2 \b");
3331  if (kcountHBnegativedirectionDigi2 == 4)
3332  HBnegativedirectionDigi2->SetXTitle("R for HB- jeta = -13; depth = 2 \b");
3333  if (kcountHBnegativedirectionDigi2 == 5)
3334  HBnegativedirectionDigi2->SetXTitle("R for HB- jeta = -12; depth = 2 \b");
3335  if (kcountHBnegativedirectionDigi2 == 6)
3336  HBnegativedirectionDigi2->SetXTitle("R for HB- jeta = -11; depth = 2 \b");
3337  if (kcountHBnegativedirectionDigi2 == 7)
3338  HBnegativedirectionDigi2->SetXTitle("R for HB- jeta = -10; depth = 2 \b");
3339  if (kcountHBnegativedirectionDigi2 == 8)
3340  HBnegativedirectionDigi2->SetXTitle("R for HB- jeta = -9; depth = 2 \b");
3341  if (kcountHBnegativedirectionDigi2 == 9)
3342  HBnegativedirectionDigi2->SetXTitle("R for HB- jeta = -8; depth = 2 \b");
3343  if (kcountHBnegativedirectionDigi2 == 10)
3344  HBnegativedirectionDigi2->SetXTitle("R for HB- jeta = -7; depth = 2 \b");
3345  if (kcountHBnegativedirectionDigi2 == 11)
3346  HBnegativedirectionDigi2->SetXTitle("R for HB- jeta = -6; depth = 2 \b");
3347  if (kcountHBnegativedirectionDigi2 == 12)
3348  HBnegativedirectionDigi2->SetXTitle("R for HB- jeta = -5; depth = 2 \b");
3349  if (kcountHBnegativedirectionDigi2 == 13)
3350  HBnegativedirectionDigi2->SetXTitle("R for HB- jeta = -4; depth = 2 \b");
3351  if (kcountHBnegativedirectionDigi2 == 14)
3352  HBnegativedirectionDigi2->SetXTitle("R for HB- jeta = -3; depth = 2 \b");
3353  if (kcountHBnegativedirectionDigi2 == 15)
3354  HBnegativedirectionDigi2->SetXTitle("R for HB- jeta = -2; depth = 2 \b");
3355  if (kcountHBnegativedirectionDigi2 == 16)
3356  HBnegativedirectionDigi2->SetXTitle("R for HB- jeta = -1; depth = 2 \b");
3357  HBnegativedirectionDigi2->Draw("Error");
3358  kcountHBnegativedirectionDigi2++;
3359  if (kcountHBnegativedirectionDigi2 > 16)
3360  break; // 4x6 = 24
3361  } //ccctest>0
3362 
3363  } // for i
3364  } //if(jeta-41 < 0 )
3365  } //for jeta
3367  c3x5->Update();
3368  c3x5->Print("RdigiNegativeDirectionhistD1PhiSymmetryDepth2HB.png");
3369  c3x5->Clear();
3370  // clean-up
3371  if (h2CeffHBnegativedirectionDigi2)
3372  delete h2CeffHBnegativedirectionDigi2;
3373  //========================================================================================== 1116
3374  //======================================================================
3375  //======================================================================1D plot: R vs phi , different eta, depth=3
3376  //cout<<" 1D plot: R vs phi , different eta, depth=3 *****" <<endl;
3377  c3x5->Clear();
3379  c3x5->Divide(4, 4);
3380  c3x5->cd(1);
3381  int kcountHBnegativedirectionDigi3 = 1;
3382  TH1F *h2CeffHBnegativedirectionDigi3 = new TH1F("h2CeffHBnegativedirectionDigi3", "", nphi, 0., 72.);
3383  for (int jeta = 0; jeta < njeta; jeta++) {
3384  // negativedirectionDigi:
3385  if (jeta - 41 < 0) {
3386  // for (int i=0;i<ndepth;i++) {
3387  // depth=3
3388  for (int i = 2; i < 3; i++) {
3389  TH1F *HBnegativedirectionDigi3 = (TH1F *)h2CeffHBnegativedirectionDigi3->Clone("twod1");
3390  float ccctest = 0; // to avoid empty massive elements
3391  for (int jphi = 0; jphi < nphi; jphi++) {
3392  double ccc1 = adigiHB[i][jeta][jphi];
3393  if (ccc1 != 0.) {
3394  HBnegativedirectionDigi3->Fill(jphi, ccc1);
3395  ccctest = 1.; //HBnegativedirectionDigi3->SetBinError(i,0.01);
3396  }
3397  } // for jphi
3398  if (ccctest > 0.) {
3399  //cout<<"666 kcountHBnegativedirectionDigi3 = "<<kcountHBnegativedirectionDigi3 <<" jeta-41= "<< jeta-41 <<endl;
3400  c3x5->cd(kcountHBnegativedirectionDigi3);
3401  HBnegativedirectionDigi3->SetMarkerStyle(20);
3402  HBnegativedirectionDigi3->SetMarkerSize(0.4);
3403  HBnegativedirectionDigi3->GetYaxis()->SetLabelSize(0.04);
3404  HBnegativedirectionDigi3->SetXTitle("HBnegativedirectionDigi3 \b");
3405  HBnegativedirectionDigi3->SetMarkerColor(2);
3406  HBnegativedirectionDigi3->SetLineColor(0);
3407  gPad->SetGridy();
3408  gPad->SetGridx();
3409  // gPad->SetLogy();
3410  if (kcountHBnegativedirectionDigi3 == 1)
3411  HBnegativedirectionDigi3->SetXTitle("R for HB- jeta = -16; depth = 3 \b");
3412  if (kcountHBnegativedirectionDigi3 == 2)
3413  HBnegativedirectionDigi3->SetXTitle("R for HB- jeta = -15; depth = 3 \b");
3414  if (kcountHBnegativedirectionDigi3 == 3)
3415  HBnegativedirectionDigi3->SetXTitle("R for HB- jeta = -14; depth = 3 \b");
3416  if (kcountHBnegativedirectionDigi3 == 4)
3417  HBnegativedirectionDigi3->SetXTitle("R for HB- jeta = -13; depth = 3 \b");
3418  if (kcountHBnegativedirectionDigi3 == 5)
3419  HBnegativedirectionDigi3->SetXTitle("R for HB- jeta = -12; depth = 3 \b");
3420  if (kcountHBnegativedirectionDigi3 == 6)
3421  HBnegativedirectionDigi3->SetXTitle("R for HB- jeta = -11; depth = 3 \b");
3422  if (kcountHBnegativedirectionDigi3 == 7)
3423  HBnegativedirectionDigi3->SetXTitle("R for HB- jeta = -10; depth = 3 \b");
3424  if (kcountHBnegativedirectionDigi3 == 8)
3425  HBnegativedirectionDigi3->SetXTitle("R for HB- jeta = -9; depth = 3 \b");
3426  if (kcountHBnegativedirectionDigi3 == 9)
3427  HBnegativedirectionDigi3->SetXTitle("R for HB- jeta = -8; depth = 3 \b");
3428  if (kcountHBnegativedirectionDigi3 == 10)
3429  HBnegativedirectionDigi3->SetXTitle("R for HB- jeta = -7; depth = 3 \b");
3430  if (kcountHBnegativedirectionDigi3 == 11)
3431  HBnegativedirectionDigi3->SetXTitle("R for HB- jeta = -6; depth = 3 \b");
3432  if (kcountHBnegativedirectionDigi3 == 12)
3433  HBnegativedirectionDigi3->SetXTitle("R for HB- jeta = -5; depth = 3 \b");
3434  if (kcountHBnegativedirectionDigi3 == 13)
3435  HBnegativedirectionDigi3->SetXTitle("R for HB- jeta = -4; depth = 3 \b");
3436  if (kcountHBnegativedirectionDigi3 == 14)
3437  HBnegativedirectionDigi3->SetXTitle("R for HB- jeta = -3; depth = 3 \b");
3438  if (kcountHBnegativedirectionDigi3 == 15)
3439  HBnegativedirectionDigi3->SetXTitle("R for HB- jeta = -2; depth = 3 \b");
3440  if (kcountHBnegativedirectionDigi3 == 16)
3441  HBnegativedirectionDigi3->SetXTitle("R for HB- jeta = -1; depth = 3 \b");
3442 
3443  HBnegativedirectionDigi3->Draw("Error");
3444  kcountHBnegativedirectionDigi3++;
3445  if (kcountHBnegativedirectionDigi3 > 16)
3446  break; // 4x6 = 24
3447  } //ccctest>0
3448 
3449  } // for i
3450  } //if(jeta-41 < 0 )
3451  } //for jeta
3453  c3x5->Update();
3454  c3x5->Print("RdigiNegativeDirectionhistD1PhiSymmetryDepth3HB.png");
3455  c3x5->Clear();
3456  // clean-up
3457  if (h2CeffHBnegativedirectionDigi3)
3458  delete h2CeffHBnegativedirectionDigi3;
3459  //========================================================================================== 1117
3460  //======================================================================
3461  //======================================================================1D plot: R vs phi , different eta, depth=4
3462  //cout<<" 1D plot: R vs phi , different eta, depth=4 *****" <<endl;
3463  c3x5->Clear();
3465  c3x5->Divide(4, 4);
3466  c3x5->cd(1);
3467  int kcountHBnegativedirectionDigi4 = 1;
3468  TH1F *h2CeffHBnegativedirectionDigi4 = new TH1F("h2CeffHBnegativedirectionDigi4", "", nphi, 0., 72.);
3469 
3470  for (int jeta = 0; jeta < njeta; jeta++) {
3471  // negativedirectionDigi:
3472  if (jeta - 41 < 0) {
3473  // for (int i=0;i<ndepth;i++) {
3474  // depth=4
3475  for (int i = 3; i < 4; i++) {
3476  TH1F *HBnegativedirectionDigi4 = (TH1F *)h2CeffHBnegativedirectionDigi4->Clone("twod1");
3477 
3478  float ccctest = 0; // to avoid empty massive elements
3479  for (int jphi = 0; jphi < nphi; jphi++) {
3480  double ccc1 = adigiHB[i][jeta][jphi];
3481  if (ccc1 != 0.) {
3482  HBnegativedirectionDigi4->Fill(jphi, ccc1);
3483  ccctest = 1.; //HBnegativedirectionDigi4->SetBinError(i,0.01);
3484  }
3485  } // for jphi
3486  if (ccctest > 0.) {
3487  //cout<<"777 kcountHBnegativedirectionDigi4 = "<<kcountHBnegativedirectionDigi4 <<" jeta-41= "<< jeta-41 <<endl;
3488  c3x5->cd(kcountHBnegativedirectionDigi4);
3489  HBnegativedirectionDigi4->SetMarkerStyle(20);
3490  HBnegativedirectionDigi4->SetMarkerSize(0.4);
3491  HBnegativedirectionDigi4->GetYaxis()->SetLabelSize(0.04);
3492  HBnegativedirectionDigi4->SetXTitle("HBnegativedirectionDigi4 \b");
3493  HBnegativedirectionDigi4->SetMarkerColor(2);
3494  HBnegativedirectionDigi4->SetLineColor(0);
3495  gPad->SetGridy();
3496  gPad->SetGridx();
3497  // gPad->SetLogy();
3498  if (kcountHBnegativedirectionDigi4 == 1)
3499  HBnegativedirectionDigi4->SetXTitle("R for HB- jeta = -16; depth = 4 \b");
3500  if (kcountHBnegativedirectionDigi4 == 2)
3501  HBnegativedirectionDigi4->SetXTitle("R for HB- jeta = -15; depth = 4 \b");
3502  if (kcountHBnegativedirectionDigi4 == 3)
3503  HBnegativedirectionDigi4->SetXTitle("R for HB- jeta = -14; depth = 4 \b");
3504  if (kcountHBnegativedirectionDigi4 == 4)
3505  HBnegativedirectionDigi4->SetXTitle("R for HB- jeta = -13; depth = 4 \b");
3506  if (kcountHBnegativedirectionDigi4 == 5)
3507  HBnegativedirectionDigi4->SetXTitle("R for HB- jeta = -12; depth = 4 \b");
3508  if (kcountHBnegativedirectionDigi4 == 6)
3509  HBnegativedirectionDigi4->SetXTitle("R for HB- jeta = -11; depth = 4 \b");
3510  if (kcountHBnegativedirectionDigi4 == 7)
3511  HBnegativedirectionDigi4->SetXTitle("R for HB- jeta = -10; depth = 4 \b");
3512  if (kcountHBnegativedirectionDigi4 == 8)
3513  HBnegativedirectionDigi4->SetXTitle("R for HB- jeta = -9; depth = 4 \b");
3514  if (kcountHBnegativedirectionDigi4 == 9)
3515  HBnegativedirectionDigi4->SetXTitle("R for HB- jeta = -8; depth = 4 \b");
3516  if (kcountHBnegativedirectionDigi4 == 10)
3517  HBnegativedirectionDigi4->SetXTitle("R for HB- jeta = -7; depth = 4 \b");
3518  if (kcountHBnegativedirectionDigi4 == 11)
3519  HBnegativedirectionDigi4->SetXTitle("R for HB- jeta = -6; depth = 4 \b");
3520  if (kcountHBnegativedirectionDigi4 == 12)
3521  HBnegativedirectionDigi4->SetXTitle("R for HB- jeta = -5; depth = 4 \b");
3522  if (kcountHBnegativedirectionDigi4 == 13)
3523  HBnegativedirectionDigi4->SetXTitle("R for HB- jeta = -4; depth = 4 \b");
3524  if (kcountHBnegativedirectionDigi4 == 14)
3525  HBnegativedirectionDigi4->SetXTitle("R for HB- jeta = -3; depth = 4 \b");
3526  if (kcountHBnegativedirectionDigi4 == 15)
3527  HBnegativedirectionDigi4->SetXTitle("R for HB- jeta = -2; depth = 4 \b");
3528  if (kcountHBnegativedirectionDigi4 == 16)
3529  HBnegativedirectionDigi4->SetXTitle("R for HB- jeta = -1; depth = 4 \b");
3530  HBnegativedirectionDigi4->Draw("Error");
3531  kcountHBnegativedirectionDigi4++;
3532  if (kcountHBnegativedirectionDigi4 > 16)
3533  break; // 4x6 = 24
3534  } //ccctest>0
3535 
3536  } // for i
3537  } //if(jeta-41 < 0 )
3538  } //for jeta
3540  c3x5->Update();
3541  c3x5->Print("RdigiNegativeDirectionhistD1PhiSymmetryDepth4HB.png");
3542  c3x5->Clear();
3543  // clean-up
3544  if (h2CeffHBnegativedirectionDigi4)
3545  delete h2CeffHBnegativedirectionDigi4;
3546 
3547  //======================================================================================================================
3548  //======================================================================================================================
3549  //======================================================================================================================
3550  // DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD:
3551 
3552  //cout<<" Start Vaiance: preparation *****" <<endl;
3553  TH2F *digiVariance1HB1 = (TH2F *)dir->FindObjectAny("h_amplitudechannel2_HB1");
3554  TH2F *digiVariance0HB1 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HB1");
3555  TH2F *digiVarianceHB1 = (TH2F *)digiVariance1HB1->Clone("digiVarianceHB1");
3556  digiVarianceHB1->Divide(digiVariance1HB1, digiVariance0HB1, 1, 1, "B");
3557  TH2F *digiVariance1HB2 = (TH2F *)dir->FindObjectAny("h_amplitudechannel2_HB2");
3558  TH2F *digiVariance0HB2 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HB2");
3559  TH2F *digiVarianceHB2 = (TH2F *)digiVariance1HB2->Clone("digiVarianceHB2");
3560  digiVarianceHB2->Divide(digiVariance1HB2, digiVariance0HB2, 1, 1, "B");
3561  TH2F *digiVariance1HB3 = (TH2F *)dir->FindObjectAny("h_amplitudechannel2_HB3");
3562  TH2F *digiVariance0HB3 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HB3");
3563  TH2F *digiVarianceHB3 = (TH2F *)digiVariance1HB3->Clone("digiVarianceHB3");
3564  digiVarianceHB3->Divide(digiVariance1HB3, digiVariance0HB3, 1, 1, "B");
3565  TH2F *digiVariance1HB4 = (TH2F *)dir->FindObjectAny("h_amplitudechannel2_HB4");
3566  TH2F *digiVariance0HB4 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HB4");
3567  TH2F *digiVarianceHB4 = (TH2F *)digiVariance1HB4->Clone("digiVarianceHB4");
3568  digiVarianceHB4->Divide(digiVariance1HB4, digiVariance0HB4, 1, 1, "B");
3569  //cout<<" Vaiance: preparation DONE *****" <<endl;
3570  //====================================================================== put Vaiance=Dispersia = Sig**2=<R**2> - (<R>)**2 into massive digivarianceHB
3571  // = sum(R*R)/N - (sum(R)/N)**2
3572  for (int jeta = 0; jeta < njeta; jeta++) {
3573  //preparation for PHI normalization:
3574  double sumdigiHB0 = 0;
3575  int nsumdigiHB0 = 0;
3576  double sumdigiHB1 = 0;
3577  int nsumdigiHB1 = 0;
3578  double sumdigiHB2 = 0;
3579  int nsumdigiHB2 = 0;
3580  double sumdigiHB3 = 0;
3581  int nsumdigiHB3 = 0;
3582  for (int jphi = 0; jphi < njphi; jphi++) {
3583  digivarianceHB[0][jeta][jphi] = digiVarianceHB1->GetBinContent(jeta + 1, jphi + 1);
3584  digivarianceHB[1][jeta][jphi] = digiVarianceHB2->GetBinContent(jeta + 1, jphi + 1);
3585  digivarianceHB[2][jeta][jphi] = digiVarianceHB3->GetBinContent(jeta + 1, jphi + 1);
3586  digivarianceHB[3][jeta][jphi] = digiVarianceHB4->GetBinContent(jeta + 1, jphi + 1);
3587  if (digivarianceHB[0][jeta][jphi] > 0.) {
3588  sumdigiHB0 += digivarianceHB[0][jeta][jphi];
3589  ++nsumdigiHB0;
3590  }
3591  if (digivarianceHB[1][jeta][jphi] > 0.) {
3592  sumdigiHB1 += digivarianceHB[1][jeta][jphi];
3593  ++nsumdigiHB1;
3594  }
3595  if (digivarianceHB[2][jeta][jphi] > 0.) {
3596  sumdigiHB2 += digivarianceHB[2][jeta][jphi];
3597  ++nsumdigiHB2;
3598  }
3599  if (digivarianceHB[3][jeta][jphi] > 0.) {
3600  sumdigiHB3 += digivarianceHB[3][jeta][jphi];
3601  ++nsumdigiHB3;
3602  }
3603  } // phi
3604  // PHI normalization :
3605  for (int jphi = 0; jphi < njphi; jphi++) {
3606  if (digivarianceHB[0][jeta][jphi] > 0.)
3607  digivarianceHB[0][jeta][jphi] /= (sumdigiHB0 / nsumdigiHB0);
3608  if (digivarianceHB[1][jeta][jphi] > 0.)
3609  digivarianceHB[1][jeta][jphi] /= (sumdigiHB1 / nsumdigiHB1);
3610  if (digivarianceHB[2][jeta][jphi] > 0.)
3611  digivarianceHB[2][jeta][jphi] /= (sumdigiHB2 / nsumdigiHB2);
3612  if (digivarianceHB[3][jeta][jphi] > 0.)
3613  digivarianceHB[3][jeta][jphi] /= (sumdigiHB3 / nsumdigiHB3);
3614  } // phi
3615  // digivarianceHB (D) = sum(R*R)/N - (sum(R)/N)**2
3616  for (int jphi = 0; jphi < njphi; jphi++) {
3617  // cout<<"12 12 12 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
3618  digivarianceHB[0][jeta][jphi] -= adigiHB[0][jeta][jphi] * adigiHB[0][jeta][jphi];
3619  digivarianceHB[0][jeta][jphi] = fabs(digivarianceHB[0][jeta][jphi]);
3620  digivarianceHB[1][jeta][jphi] -= adigiHB[1][jeta][jphi] * adigiHB[1][jeta][jphi];
3621  digivarianceHB[1][jeta][jphi] = fabs(digivarianceHB[1][jeta][jphi]);
3622  digivarianceHB[2][jeta][jphi] -= adigiHB[2][jeta][jphi] * adigiHB[2][jeta][jphi];
3623  digivarianceHB[2][jeta][jphi] = fabs(digivarianceHB[2][jeta][jphi]);
3624  digivarianceHB[3][jeta][jphi] -= adigiHB[3][jeta][jphi] * adigiHB[3][jeta][jphi];
3625  digivarianceHB[3][jeta][jphi] = fabs(digivarianceHB[3][jeta][jphi]);
3626  }
3627  }
3628  //cout<<" Vaiance: DONE*****" <<endl;
3629  //------------------------ 2D-eta/phi-plot: D, averaged over depthfs
3630  //======================================================================
3631  //======================================================================
3632  //cout<<" R2D-eta/phi-plot: D, averaged over depthfs *****" <<endl;
3633  c1x1->Clear();
3635  c1x0->Divide(1, 1);
3636  c1x0->cd(1);
3637  TH2F *DefzDdigiHB42D = new TH2F("DefzDdigiHB42D", "", neta, -41., 41., nphi, 0., 72.);
3638  TH2F *DefzDdigiHB42D0 = new TH2F("DefzDdigiHB42D0", "", neta, -41., 41., nphi, 0., 72.);
3639  TH2F *DefzDdigiHB42DF = (TH2F *)DefzDdigiHB42D0->Clone("DefzDdigiHB42DF");
3640  for (int i = 0; i < ndepth; i++) {
3641  for (int jeta = 0; jeta < neta; jeta++) {
3642  for (int jphi = 0; jphi < nphi; jphi++) {
3643  double ccc1 = digivarianceHB[i][jeta][jphi];
3644  int k2plot = jeta - 41;
3645  int kkk = k2plot; //if(k2plot >0 kkk=k2plot+1; //-41 +41 !=0
3646  if (adigiHB[i][jeta][jphi] > 0.) {
3647  DefzDdigiHB42D->Fill(kkk, jphi, ccc1);
3648  DefzDdigiHB42D0->Fill(kkk, jphi, 1.);
3649  }
3650  }
3651  }
3652  }
3653  DefzDdigiHB42DF->Divide(DefzDdigiHB42D, DefzDdigiHB42D0, 1, 1, "B"); // average A
3654  // DefzDdigiHB1->Sumw2();
3655  gPad->SetGridy();
3656  gPad->SetGridx(); // gPad->SetLogz();
3657  DefzDdigiHB42DF->SetMarkerStyle(20);
3658  DefzDdigiHB42DF->SetMarkerSize(0.4);
3659  DefzDdigiHB42DF->GetZaxis()->SetLabelSize(0.08);
3660  DefzDdigiHB42DF->SetXTitle("<D>_depth #eta \b");
3661  DefzDdigiHB42DF->SetYTitle(" #phi \b");
3662  DefzDdigiHB42DF->SetZTitle("<D>_depth \b");
3663  DefzDdigiHB42DF->SetMarkerColor(2);
3664  DefzDdigiHB42DF->SetLineColor(
3665  0); // DefzDdigiHB42DF->SetMaximum(1.000); // DefzDdigiHB42DF->SetMinimum(1.0);
3666  DefzDdigiHB42DF->Draw("COLZ");
3668  c1x0->Update();
3669  c1x0->Print("DdigiGeneralD2PhiSymmetryHB.png");
3670  c1x0->Clear();
3671  // clean-up
3672  if (DefzDdigiHB42D)
3673  delete DefzDdigiHB42D;
3674  if (DefzDdigiHB42D0)
3675  delete DefzDdigiHB42D0;
3676  if (DefzDdigiHB42DF)
3677  delete DefzDdigiHB42DF;
3678  //====================================================================== 1D plot: D vs phi , averaged over depthfs & eta
3679  //======================================================================
3680  //cout<<" 1D plot: D vs phi , averaged over depthfs & eta *****" <<endl;
3681  c1x1->Clear();
3683  c1x1->Divide(1, 1);
3684  c1x1->cd(1);
3685  TH1F *DefzDdigiHB41D = new TH1F("DefzDdigiHB41D", "", nphi, 0., 72.);
3686  TH1F *DefzDdigiHB41D0 = new TH1F("DefzDdigiHB41D0", "", nphi, 0., 72.);
3687  TH1F *DefzDdigiHB41DF = (TH1F *)DefzDdigiHB41D0->Clone("DefzDdigiHB41DF");
3688 
3689  for (int jphi = 0; jphi < nphi; jphi++) {
3690  for (int jeta = 0; jeta < neta; jeta++) {
3691  for (int i = 0; i < ndepth; i++) {
3692  double ccc1 = digivarianceHB[i][jeta][jphi];
3693  if (adigiHB[i][jeta][jphi] > 0.) {
3694  DefzDdigiHB41D->Fill(jphi, ccc1);
3695  DefzDdigiHB41D0->Fill(jphi, 1.);
3696  }
3697  }
3698  }
3699  }
3700  // DefzDdigiHB41D->Sumw2();DefzDdigiHB41D0->Sumw2();
3701 
3702  DefzDdigiHB41DF->Divide(DefzDdigiHB41D, DefzDdigiHB41D0, 1, 1, "B"); // R averaged over depthfs & eta
3703  DefzDdigiHB41D0->Sumw2();
3704  // for (int jphi=1;jphi<73;jphi++) {DefzDdigiHB41DF->SetBinError(jphi,0.01);}
3705  gPad->SetGridy();
3706  gPad->SetGridx(); // gPad->SetLogz();
3707  DefzDdigiHB41DF->SetMarkerStyle(20);
3708  DefzDdigiHB41DF->SetMarkerSize(1.4);
3709  DefzDdigiHB41DF->GetZaxis()->SetLabelSize(0.08);
3710  DefzDdigiHB41DF->SetXTitle("#phi \b");
3711  DefzDdigiHB41DF->SetYTitle(" <D> \b");
3712  DefzDdigiHB41DF->SetZTitle("<D>_PHI - AllDepthfs \b");
3713  DefzDdigiHB41DF->SetMarkerColor(4);
3714  DefzDdigiHB41DF->SetLineColor(4); // DefzDdigiHB41DF->SetMinimum(0.8); DefzDdigiHB41DF->SetMinimum(-0.015);
3715  DefzDdigiHB41DF->Draw("Error");
3717  c1x1->Update();
3718  c1x1->Print("DdigiGeneralD1PhiSymmetryHB.png");
3719  c1x1->Clear();
3720  // clean-up
3721  if (DefzDdigiHB41D)
3722  delete DefzDdigiHB41D;
3723  if (DefzDdigiHB41D0)
3724  delete DefzDdigiHB41D0;
3725  if (DefzDdigiHB41DF)
3726  delete DefzDdigiHB41DF;
3727 
3728  //========================================================================================== 14
3729  //======================================================================
3730  //======================================================================1D plot: D vs phi , different eta, depth=1
3731  //cout<<" 1D plot: D vs phi , different eta, depth=1 *****" <<endl;
3732  c3x5->Clear();
3734  c3x5->Divide(4, 4);
3735  c3x5->cd(1);
3736  int kcountHBpositivedirectionDigiD1 = 1;
3737  TH1F *h2CeffHBpositivedirectionDigiD1 = new TH1F("h2CeffHBpositivedirectionDigiD1", "", nphi, 0., 72.);
3738 
3739  for (int jeta = 0; jeta < njeta; jeta++) {
3740  // positivedirectionDigiD:
3741  if (jeta - 41 >= 0) {
3742  // for (int i=0;i<ndepth;i++) {
3743  // depth=1
3744  for (int i = 0; i < 1; i++) {
3745  TH1F *HBpositivedirectionDigiD1 = (TH1F *)h2CeffHBpositivedirectionDigiD1->Clone("twod1");
3746 
3747  float ccctest = 0; // to avoid empty massive elements
3748  for (int jphi = 0; jphi < nphi; jphi++) {
3749  double ccc1 = digivarianceHB[i][jeta][jphi];
3750  if (adigiHB[i][jeta][jphi] > 0.) {
3751  HBpositivedirectionDigiD1->Fill(jphi, ccc1);
3752  ccctest = 1.; //HBpositivedirectionDigiD1->SetBinError(i,0.01);
3753  }
3754  } // for jphi
3755  if (ccctest > 0.) {
3756  //cout<<"1414 kcountHBpositivedirectionDigiD1 = "<<kcountHBpositivedirectionDigiD1 <<" jeta-41= "<< jeta-41 <<endl;
3757  c3x5->cd(kcountHBpositivedirectionDigiD1);
3758  HBpositivedirectionDigiD1->SetMarkerStyle(20);
3759  HBpositivedirectionDigiD1->SetMarkerSize(0.4);
3760  HBpositivedirectionDigiD1->GetYaxis()->SetLabelSize(0.04);
3761  HBpositivedirectionDigiD1->SetXTitle("HBpositivedirectionDigiD1 \b");
3762  HBpositivedirectionDigiD1->SetMarkerColor(2);
3763  HBpositivedirectionDigiD1->SetLineColor(0);
3764  gPad->SetGridy();
3765  gPad->SetGridx();
3766  // gPad->SetLogy();
3767  if (kcountHBpositivedirectionDigiD1 == 1)
3768  HBpositivedirectionDigiD1->SetXTitle("D for HB+ jeta = 0; depth = 1 \b");
3769  if (kcountHBpositivedirectionDigiD1 == 2)
3770  HBpositivedirectionDigiD1->SetXTitle("D for HB+ jeta = 1; depth = 1 \b");
3771  if (kcountHBpositivedirectionDigiD1 == 3)
3772  HBpositivedirectionDigiD1->SetXTitle("D for HB+ jeta = 2; depth = 1 \b");
3773  if (kcountHBpositivedirectionDigiD1 == 4)
3774  HBpositivedirectionDigiD1->SetXTitle("D for HB+ jeta = 3; depth = 1 \b");
3775  if (kcountHBpositivedirectionDigiD1 == 5)
3776  HBpositivedirectionDigiD1->SetXTitle("D for HB+ jeta = 4; depth = 1 \b");
3777  if (kcountHBpositivedirectionDigiD1 == 6)
3778  HBpositivedirectionDigiD1->SetXTitle("D for HB+ jeta = 5; depth = 1 \b");
3779  if (kcountHBpositivedirectionDigiD1 == 7)
3780  HBpositivedirectionDigiD1->SetXTitle("D for HB+ jeta = 6; depth = 1 \b");
3781  if (kcountHBpositivedirectionDigiD1 == 8)
3782  HBpositivedirectionDigiD1->SetXTitle("D for HB+ jeta = 7; depth = 1 \b");
3783  if (kcountHBpositivedirectionDigiD1 == 9)
3784  HBpositivedirectionDigiD1->SetXTitle("D for HB+ jeta = 8; depth = 1 \b");
3785  if (kcountHBpositivedirectionDigiD1 == 10)
3786  HBpositivedirectionDigiD1->SetXTitle("D for HB+ jeta = 9; depth = 1 \b");
3787  if (kcountHBpositivedirectionDigiD1 == 11)
3788  HBpositivedirectionDigiD1->SetXTitle("D for HB+ jeta = 10; depth = 1 \b");
3789  if (kcountHBpositivedirectionDigiD1 == 12)
3790  HBpositivedirectionDigiD1->SetXTitle("D for HB+ jeta = 11; depth = 1 \b");
3791  if (kcountHBpositivedirectionDigiD1 == 13)
3792  HBpositivedirectionDigiD1->SetXTitle("D for HB+ jeta = 12; depth = 1 \b");
3793  if (kcountHBpositivedirectionDigiD1 == 14)
3794  HBpositivedirectionDigiD1->SetXTitle("D for HB+ jeta = 13; depth = 1 \b");
3795  if (kcountHBpositivedirectionDigiD1 == 15)
3796  HBpositivedirectionDigiD1->SetXTitle("D for HB+ jeta = 14; depth = 1 \b");
3797  if (kcountHBpositivedirectionDigiD1 == 16)
3798  HBpositivedirectionDigiD1->SetXTitle("D for HB+ jeta = 15; depth = 1 \b");
3799  HBpositivedirectionDigiD1->Draw("Error");
3800  kcountHBpositivedirectionDigiD1++;
3801  if (kcountHBpositivedirectionDigiD1 > 16)
3802  break; // 4x6 = 24
3803  } //ccctest>0
3804 
3805  } // for i
3806  } //if(jeta-41 >= 0)
3807  } //for jeta
3809  c3x5->Update();
3810  c3x5->Print("DdigiPositiveDirectionhistD1PhiSymmetryDepth1HB.png");
3811  c3x5->Clear();
3812  // clean-up
3813  if (h2CeffHBpositivedirectionDigiD1)
3814  delete h2CeffHBpositivedirectionDigiD1;
3815  //========================================================================================== 15
3816  //======================================================================
3817  //======================================================================1D plot: D vs phi , different eta, depth=2
3818  //cout<<" 1D plot: D vs phi , different eta, depth=2 *****" <<endl;
3819  c3x5->Clear();
3820  c3x5->Divide(4, 4);
3821  c3x5->cd(1);
3822  int kcountHBpositivedirectionDigiD2 = 1;
3823  TH1F *h2CeffHBpositivedirectionDigiD2 = new TH1F("h2CeffHBpositivedirectionDigiD2", "", nphi, 0., 72.);
3824 
3825  for (int jeta = 0; jeta < njeta; jeta++) {
3826  // positivedirectionDigiD:
3827  if (jeta - 41 >= 0) {
3828  // for (int i=0;i<ndepth;i++) {
3829  // depth=2
3830  for (int i = 1; i < 2; i++) {
3831  TH1F *HBpositivedirectionDigiD2 = (TH1F *)h2CeffHBpositivedirectionDigiD2->Clone("twod1");
3832 
3833  float ccctest = 0; // to avoid empty massive elements
3834  for (int jphi = 0; jphi < nphi; jphi++) {
3835  double ccc1 = digivarianceHB[i][jeta][jphi];
3836  if (adigiHB[i][jeta][jphi] > 0.) {
3837  HBpositivedirectionDigiD2->Fill(jphi, ccc1);
3838  ccctest = 1.; //HBpositivedirectionDigiD2->SetBinError(i,0.01);
3839  }
3840  } // for jphi
3841  if (ccctest > 0.) {
3842  //cout<<"1515 kcountHBpositivedirectionDigiD2 = "<<kcountHBpositivedirectionDigiD2 <<" jeta-41= "<< jeta-41 <<endl;
3843  c3x5->cd(kcountHBpositivedirectionDigiD2);
3844  HBpositivedirectionDigiD2->SetMarkerStyle(20);
3845  HBpositivedirectionDigiD2->SetMarkerSize(0.4);
3846  HBpositivedirectionDigiD2->GetYaxis()->SetLabelSize(0.04);
3847  HBpositivedirectionDigiD2->SetXTitle("HBpositivedirectionDigiD2 \b");
3848  HBpositivedirectionDigiD2->SetMarkerColor(2);
3849  HBpositivedirectionDigiD2->SetLineColor(0);
3850  gPad->SetGridy();
3851  gPad->SetGridx();
3852  // gPad->SetLogy();
3853  if (kcountHBpositivedirectionDigiD2 == 1)
3854  HBpositivedirectionDigiD2->SetXTitle("D for HB+ jeta = 0; depth = 2 \b");
3855  if (kcountHBpositivedirectionDigiD2 == 2)
3856  HBpositivedirectionDigiD2->SetXTitle("D for HB+ jeta = 1; depth = 2 \b");
3857  if (kcountHBpositivedirectionDigiD2 == 3)
3858  HBpositivedirectionDigiD2->SetXTitle("D for HB+ jeta = 2; depth = 2 \b");
3859  if (kcountHBpositivedirectionDigiD2 == 4)
3860  HBpositivedirectionDigiD2->SetXTitle("D for HB+ jeta = 3; depth = 2 \b");
3861  if (kcountHBpositivedirectionDigiD2 == 5)
3862  HBpositivedirectionDigiD2->SetXTitle("D for HB+ jeta = 4; depth = 2 \b");
3863  if (kcountHBpositivedirectionDigiD2 == 6)
3864  HBpositivedirectionDigiD2->SetXTitle("D for HB+ jeta = 5; depth = 2 \b");
3865  if (kcountHBpositivedirectionDigiD2 == 7)
3866  HBpositivedirectionDigiD2->SetXTitle("D for HB+ jeta = 6; depth = 2 \b");
3867  if (kcountHBpositivedirectionDigiD2 == 8)
3868  HBpositivedirectionDigiD2->SetXTitle("D for HB+ jeta = 7; depth = 2 \b");
3869  if (kcountHBpositivedirectionDigiD2 == 9)
3870  HBpositivedirectionDigiD2->SetXTitle("D for HB+ jeta = 8; depth = 2 \b");
3871  if (kcountHBpositivedirectionDigiD2 == 10)
3872  HBpositivedirectionDigiD2->SetXTitle("D for HB+ jeta = 9; depth = 2 \b");
3873  if (kcountHBpositivedirectionDigiD2 == 11)
3874  HBpositivedirectionDigiD2->SetXTitle("D for HB+ jeta = 10; depth = 2 \b");
3875  if (kcountHBpositivedirectionDigiD2 == 12)
3876  HBpositivedirectionDigiD2->SetXTitle("D for HB+ jeta = 11; depth = 2 \b");
3877  if (kcountHBpositivedirectionDigiD2 == 13)
3878  HBpositivedirectionDigiD2->SetXTitle("D for HB+ jeta = 12; depth = 2 \b");
3879  if (kcountHBpositivedirectionDigiD2 == 14)
3880  HBpositivedirectionDigiD2->SetXTitle("D for HB+ jeta = 13; depth = 2 \b");
3881  if (kcountHBpositivedirectionDigiD2 == 15)
3882  HBpositivedirectionDigiD2->SetXTitle("D for HB+ jeta = 14; depth = 2 \b");
3883  if (kcountHBpositivedirectionDigiD2 == 16)
3884  HBpositivedirectionDigiD2->SetXTitle("D for HB+ jeta = 15; depth = 2 \b");
3885  HBpositivedirectionDigiD2->Draw("Error");
3886  kcountHBpositivedirectionDigiD2++;
3887  if (kcountHBpositivedirectionDigiD2 > 16)
3888  break; // 4x6 = 24
3889  } //ccctest>0
3890 
3891  } // for i
3892  } //if(jeta-41 >= 0)
3893  } //for jeta
3895  c3x5->Update();
3896  c3x5->Print("DdigiPositiveDirectionhistD1PhiSymmetryDepth2HB.png");
3897  c3x5->Clear();
3898  // clean-up
3899  if (h2CeffHBpositivedirectionDigiD2)
3900  delete h2CeffHBpositivedirectionDigiD2;
3901  //========================================================================================== 16
3902  //======================================================================
3903  //======================================================================1D plot: D vs phi , different eta, depth=3
3904  //cout<<" 1D plot: D vs phi , different eta, depth=3 *****" <<endl;
3905  c3x5->Clear();
3906  c3x5->Divide(4, 4);
3907  c3x5->cd(1);
3908  int kcountHBpositivedirectionDigiD3 = 1;
3909  TH1F *h2CeffHBpositivedirectionDigiD3 = new TH1F("h2CeffHBpositivedirectionDigiD3", "", nphi, 0., 72.);
3910 
3911  for (int jeta = 0; jeta < njeta; jeta++) {
3912  // positivedirectionDigiD:
3913  if (jeta - 41 >= 0) {
3914  // for (int i=0;i<ndepth;i++) {
3915  // depth=3
3916  for (int i = 2; i < 3; i++) {
3917  TH1F *HBpositivedirectionDigiD3 = (TH1F *)h2CeffHBpositivedirectionDigiD3->Clone("twod1");
3918 
3919  float ccctest = 0; // to avoid empty massive elements
3920  for (int jphi = 0; jphi < nphi; jphi++) {
3921  double ccc1 = digivarianceHB[i][jeta][jphi];
3922  if (adigiHB[i][jeta][jphi] > 0.) {
3923  HBpositivedirectionDigiD3->Fill(jphi, ccc1);
3924  ccctest = 1.; //HBpositivedirectionDigiD3->SetBinError(i,0.01);
3925  }
3926  } // for jphi
3927  if (ccctest > 0.) {
3928  //cout<<"1616 kcountHBpositivedirectionDigiD3 = "<<kcountHBpositivedirectionDigiD3 <<" jeta-41= "<< jeta-41 <<endl;
3929  c3x5->cd(kcountHBpositivedirectionDigiD3);
3930  HBpositivedirectionDigiD3->SetMarkerStyle(20);
3931  HBpositivedirectionDigiD3->SetMarkerSize(0.4);
3932  HBpositivedirectionDigiD3->GetYaxis()->SetLabelSize(0.04);
3933  HBpositivedirectionDigiD3->SetXTitle("HBpositivedirectionDigiD3 \b");
3934  HBpositivedirectionDigiD3->SetMarkerColor(2);
3935  HBpositivedirectionDigiD3->SetLineColor(0);
3936  gPad->SetGridy();
3937  gPad->SetGridx();
3938  // gPad->SetLogy();
3939  if (kcountHBpositivedirectionDigiD3 == 1)
3940  HBpositivedirectionDigiD3->SetXTitle("D for HB+ jeta = 0; depth = 3 \b");
3941  if (kcountHBpositivedirectionDigiD3 == 2)
3942  HBpositivedirectionDigiD3->SetXTitle("D for HB+ jeta = 1; depth = 3 \b");
3943  if (kcountHBpositivedirectionDigiD3 == 3)
3944  HBpositivedirectionDigiD3->SetXTitle("D for HB+ jeta = 2; depth = 3 \b");
3945  if (kcountHBpositivedirectionDigiD3 == 4)
3946  HBpositivedirectionDigiD3->SetXTitle("D for HB+ jeta = 3; depth = 3 \b");
3947  if (kcountHBpositivedirectionDigiD3 == 5)
3948  HBpositivedirectionDigiD3->SetXTitle("D for HB+ jeta = 4; depth = 3 \b");
3949  if (kcountHBpositivedirectionDigiD3 == 6)
3950  HBpositivedirectionDigiD3->SetXTitle("D for HB+ jeta = 5; depth = 3 \b");
3951  if (kcountHBpositivedirectionDigiD3 == 7)
3952  HBpositivedirectionDigiD3->SetXTitle("D for HB+ jeta = 6; depth = 3 \b");
3953  if (kcountHBpositivedirectionDigiD3 == 8)
3954  HBpositivedirectionDigiD3->SetXTitle("D for HB+ jeta = 7; depth = 3 \b");
3955  if (kcountHBpositivedirectionDigiD3 == 9)
3956  HBpositivedirectionDigiD3->SetXTitle("D for HB+ jeta = 8; depth = 3 \b");
3957  if (kcountHBpositivedirectionDigiD3 == 10)
3958  HBpositivedirectionDigiD3->SetXTitle("D for HB+ jeta = 9; depth = 3 \b");
3959  if (kcountHBpositivedirectionDigiD3 == 11)
3960  HBpositivedirectionDigiD3->SetXTitle("D for HB+ jeta = 10; depth = 3 \b");
3961  if (kcountHBpositivedirectionDigiD3 == 12)
3962  HBpositivedirectionDigiD3->SetXTitle("D for HB+ jeta = 11; depth = 3 \b");
3963  if (kcountHBpositivedirectionDigiD3 == 13)
3964  HBpositivedirectionDigiD3->SetXTitle("D for HB+ jeta = 12; depth = 3 \b");
3965  if (kcountHBpositivedirectionDigiD3 == 14)
3966  HBpositivedirectionDigiD3->SetXTitle("D for HB+ jeta = 13; depth = 3 \b");
3967  if (kcountHBpositivedirectionDigiD3 == 15)
3968  HBpositivedirectionDigiD3->SetXTitle("D for HB+ jeta = 14; depth = 3 \b");
3969  if (kcountHBpositivedirectionDigiD3 == 16)
3970  HBpositivedirectionDigiD3->SetXTitle("D for HB+ jeta = 15; depth = 3 \b");
3971  HBpositivedirectionDigiD3->Draw("Error");
3972  kcountHBpositivedirectionDigiD3++;
3973  if (kcountHBpositivedirectionDigiD3 > 16)
3974  break; // 4x6 = 24
3975  } //ccctest>0
3976 
3977  } // for i
3978  } //if(jeta-41 >= 0)
3979  } //for jeta
3981  c3x5->Update();
3982  c3x5->Print("DdigiPositiveDirectionhistD1PhiSymmetryDepth3HB.png");
3983  c3x5->Clear();
3984  // clean-up
3985  if (h2CeffHBpositivedirectionDigiD3)
3986  delete h2CeffHBpositivedirectionDigiD3;
3987  //========================================================================================== 17
3988  //======================================================================
3989  //======================================================================1D plot: D vs phi , different eta, depth=4
3990  //cout<<" 1D plot: D vs phi , different eta, depth=4 *****" <<endl;
3991  c3x5->Clear();
3992  c3x5->Divide(4, 4);
3993  c3x5->cd(1);
3994  int kcountHBpositivedirectionDigiD4 = 1;
3995  TH1F *h2CeffHBpositivedirectionDigiD4 = new TH1F("h2CeffHBpositivedirectionDigiD4", "", nphi, 0., 72.);
3996 
3997  for (int jeta = 0; jeta < njeta; jeta++) {
3998  // positivedirectionDigiD:
3999  if (jeta - 41 >= 0) {
4000  // for (int i=0;i<ndepth;i++) {
4001  // depth=4
4002  for (int i = 3; i < 4; i++) {
4003  TH1F *HBpositivedirectionDigiD4 = (TH1F *)h2CeffHBpositivedirectionDigiD4->Clone("twod1");
4004 
4005  float ccctest = 0; // to avoid empty massive elements
4006  for (int jphi = 0; jphi < nphi; jphi++) {
4007  double ccc1 = digivarianceHB[i][jeta][jphi];
4008  if (adigiHB[i][jeta][jphi] > 0.) {
4009  HBpositivedirectionDigiD4->Fill(jphi, ccc1);
4010  ccctest = 1.; //HBpositivedirectionDigiD4->SetBinError(i,0.01);
4011  }
4012  } // for jphi
4013  if (ccctest > 0.) {
4014  //cout<<"1717 kcountHBpositivedirectionDigiD4 = "<<kcountHBpositivedirectionDigiD4 <<" jeta-41= "<< jeta-41 <<endl;
4015  c3x5->cd(kcountHBpositivedirectionDigiD4);
4016  HBpositivedirectionDigiD4->SetMarkerStyle(20);
4017  HBpositivedirectionDigiD4->SetMarkerSize(0.4);
4018  HBpositivedirectionDigiD4->GetYaxis()->SetLabelSize(0.04);
4019  HBpositivedirectionDigiD4->SetXTitle("HBpositivedirectionDigiD4 \b");
4020  HBpositivedirectionDigiD4->SetMarkerColor(2);
4021  HBpositivedirectionDigiD4->SetLineColor(0);
4022  gPad->SetGridy();
4023  gPad->SetGridx();
4024  // gPad->SetLogy();
4025  if (kcountHBpositivedirectionDigiD4 == 1)
4026  HBpositivedirectionDigiD4->SetXTitle("D for HB+ jeta = 0; depth = 4 \b");
4027  if (kcountHBpositivedirectionDigiD4 == 2)
4028  HBpositivedirectionDigiD4->SetXTitle("D for HB+ jeta = 1; depth = 4 \b");
4029  if (kcountHBpositivedirectionDigiD4 == 3)
4030  HBpositivedirectionDigiD4->SetXTitle("D for HB+ jeta = 2; depth = 4 \b");
4031  if (kcountHBpositivedirectionDigiD4 == 4)
4032  HBpositivedirectionDigiD4->SetXTitle("D for HB+ jeta = 3; depth = 4 \b");
4033  if (kcountHBpositivedirectionDigiD4 == 5)
4034  HBpositivedirectionDigiD4->SetXTitle("D for HB+ jeta = 4; depth = 4 \b");
4035  if (kcountHBpositivedirectionDigiD4 == 6)
4036  HBpositivedirectionDigiD4->SetXTitle("D for HB+ jeta = 5; depth = 4 \b");
4037  if (kcountHBpositivedirectionDigiD4 == 7)
4038  HBpositivedirectionDigiD4->SetXTitle("D for HB+ jeta = 6; depth = 4 \b");
4039  if (kcountHBpositivedirectionDigiD4 == 8)
4040  HBpositivedirectionDigiD4->SetXTitle("D for HB+ jeta = 7; depth = 4 \b");
4041  if (kcountHBpositivedirectionDigiD4 == 9)
4042  HBpositivedirectionDigiD4->SetXTitle("D for HB+ jeta = 8; depth = 4 \b");
4043  if (kcountHBpositivedirectionDigiD4 == 10)
4044  HBpositivedirectionDigiD4->SetXTitle("D for HB+ jeta = 9; depth = 4 \b");
4045  if (kcountHBpositivedirectionDigiD4 == 11)
4046  HBpositivedirectionDigiD4->SetXTitle("D for HB+ jeta = 10; depth = 4 \b");
4047  if (kcountHBpositivedirectionDigiD4 == 12)
4048  HBpositivedirectionDigiD4->SetXTitle("D for HB+ jeta = 11; depth = 4 \b");
4049  if (kcountHBpositivedirectionDigiD4 == 13)
4050  HBpositivedirectionDigiD4->SetXTitle("D for HB+ jeta = 12; depth = 4 \b");
4051  if (kcountHBpositivedirectionDigiD4 == 14)
4052  HBpositivedirectionDigiD4->SetXTitle("D for HB+ jeta = 13; depth = 4 \b");
4053  if (kcountHBpositivedirectionDigiD4 == 15)
4054  HBpositivedirectionDigiD4->SetXTitle("D for HB+ jeta = 14; depth = 4 \b");
4055  if (kcountHBpositivedirectionDigiD4 == 16)
4056  HBpositivedirectionDigiD4->SetXTitle("D for HB+ jeta = 15; depth = 4 \b");
4057  HBpositivedirectionDigiD4->Draw("Error");
4058  kcountHBpositivedirectionDigiD4++;
4059  if (kcountHBpositivedirectionDigiD4 > 16)
4060  break; // 4x6 = 24
4061  } //ccctest>0
4062 
4063  } // for i
4064  } //if(jeta-41 >= 0)
4065  } //for jeta
4067  c3x5->Update();
4068  c3x5->Print("DdigiPositiveDirectionhistD1PhiSymmetryDepth4HB.png");
4069  c3x5->Clear();
4070  // clean-up
4071  if (h2CeffHBpositivedirectionDigiD4)
4072  delete h2CeffHBpositivedirectionDigiD4;
4073 
4074  //========================================================================================== 22214
4075  //======================================================================
4076  //======================================================================1D plot: D vs phi , different eta, depth=1
4077  //cout<<" 1D plot: D vs phi , different eta, depth=1 *****" <<endl;
4078  c3x5->Clear();
4080  c3x5->Divide(4, 4);
4081  c3x5->cd(1);
4082  int kcountHBnegativedirectionDigiD1 = 1;
4083  TH1F *h2CeffHBnegativedirectionDigiD1 = new TH1F("h2CeffHBnegativedirectionDigiD1", "", nphi, 0., 72.);
4084 
4085  for (int jeta = 0; jeta < njeta; jeta++) {
4086  // negativedirectionDigiD:
4087  if (jeta - 41 < 0) {
4088  // for (int i=0;i<ndepth;i++) {
4089  // depth=1
4090  for (int i = 0; i < 1; i++) {
4091  TH1F *HBnegativedirectionDigiD1 = (TH1F *)h2CeffHBnegativedirectionDigiD1->Clone("twod1");
4092 
4093  float ccctest = 0; // to avoid empty massive elements
4094  for (int jphi = 0; jphi < nphi; jphi++) {
4095  double ccc1 = digivarianceHB[i][jeta][jphi];
4096  if (adigiHB[i][jeta][jphi] > 0.) {
4097  HBnegativedirectionDigiD1->Fill(jphi, ccc1);
4098  ccctest = 1.; //HBnegativedirectionDigiD1->SetBinError(i,0.01);
4099  }
4100  } // for jphi
4101  if (ccctest > 0.) {
4102  //cout<<"1414 kcountHBnegativedirectionDigiD1 = "<<kcountHBnegativedirectionDigiD1 <<" jeta-41= "<< jeta-41 <<endl;
4103  c3x5->cd(kcountHBnegativedirectionDigiD1);
4104  HBnegativedirectionDigiD1->SetMarkerStyle(20);
4105  HBnegativedirectionDigiD1->SetMarkerSize(0.4);
4106  HBnegativedirectionDigiD1->GetYaxis()->SetLabelSize(0.04);
4107  HBnegativedirectionDigiD1->SetXTitle("HBnegativedirectionDigiD1 \b");
4108  HBnegativedirectionDigiD1->SetMarkerColor(2);
4109  HBnegativedirectionDigiD1->SetLineColor(0);
4110  gPad->SetGridy();
4111  gPad->SetGridx();
4112  // gPad->SetLogy();
4113  if (kcountHBnegativedirectionDigiD1 == 1)
4114  HBnegativedirectionDigiD1->SetXTitle("D for HB- jeta =-16; depth = 1 \b");
4115  if (kcountHBnegativedirectionDigiD1 == 2)
4116  HBnegativedirectionDigiD1->SetXTitle("D for HB- jeta =-15; depth = 1 \b");
4117  if (kcountHBnegativedirectionDigiD1 == 3)
4118  HBnegativedirectionDigiD1->SetXTitle("D for HB- jeta =-14; depth = 1 \b");
4119  if (kcountHBnegativedirectionDigiD1 == 4)
4120  HBnegativedirectionDigiD1->SetXTitle("D for HB- jeta =-13; depth = 1 \b");
4121  if (kcountHBnegativedirectionDigiD1 == 5)
4122  HBnegativedirectionDigiD1->SetXTitle("D for HB- jeta =-12; depth = 1 \b");
4123  if (kcountHBnegativedirectionDigiD1 == 6)
4124  HBnegativedirectionDigiD1->SetXTitle("D for HB- jeta =-11; depth = 1 \b");
4125  if (kcountHBnegativedirectionDigiD1 == 7)
4126  HBnegativedirectionDigiD1->SetXTitle("D for HB- jeta =-10; depth = 1 \b");
4127  if (kcountHBnegativedirectionDigiD1 == 8)
4128  HBnegativedirectionDigiD1->SetXTitle("D for HB- jeta =-9; depth = 1 \b");
4129  if (kcountHBnegativedirectionDigiD1 == 9)
4130  HBnegativedirectionDigiD1->SetXTitle("D for HB- jeta =-8; depth = 1 \b");
4131  if (kcountHBnegativedirectionDigiD1 == 10)
4132  HBnegativedirectionDigiD1->SetXTitle("D for HB- jeta =-7; depth = 1 \b");
4133  if (kcountHBnegativedirectionDigiD1 == 11)
4134  HBnegativedirectionDigiD1->SetXTitle("D for HB- jeta =-6; depth = 1 \b");
4135  if (kcountHBnegativedirectionDigiD1 == 12)
4136  HBnegativedirectionDigiD1->SetXTitle("D for HB- jeta =-5; depth = 1 \b");
4137  if (kcountHBnegativedirectionDigiD1 == 13)
4138  HBnegativedirectionDigiD1->SetXTitle("D for HB- jeta =-4; depth = 1 \b");
4139  if (kcountHBnegativedirectionDigiD1 == 14)
4140  HBnegativedirectionDigiD1->SetXTitle("D for HB- jeta =-3; depth = 1 \b");
4141  if (kcountHBnegativedirectionDigiD1 == 15)
4142  HBnegativedirectionDigiD1->SetXTitle("D for HB- jeta =-2; depth = 1 \b");
4143  if (kcountHBnegativedirectionDigiD1 == 16)
4144  HBnegativedirectionDigiD1->SetXTitle("D for HB- jeta =-1; depth = 1 \b");
4145  HBnegativedirectionDigiD1->Draw("Error");
4146  kcountHBnegativedirectionDigiD1++;
4147  if (kcountHBnegativedirectionDigiD1 > 16)
4148  break; // 4x6 = 24
4149  } //ccctest>0
4150 
4151  } // for i
4152  } //if(jeta-41 < 0)
4153  } //for jeta
4155  c3x5->Update();
4156  c3x5->Print("DdigiNegativeDirectionhistD1PhiSymmetryDepth1HB.png");
4157  c3x5->Clear();
4158  // clean-up
4159  if (h2CeffHBnegativedirectionDigiD1)
4160  delete h2CeffHBnegativedirectionDigiD1;
4161  //========================================================================================== 22215
4162  //======================================================================
4163  //======================================================================1D plot: D vs phi , different eta, depth=2
4164  //cout<<" 1D plot: D vs phi , different eta, depth=2 *****" <<endl;
4165  c3x5->Clear();
4166  c3x5->Divide(4, 4);
4167  c3x5->cd(1);
4168  int kcountHBnegativedirectionDigiD2 = 1;
4169  TH1F *h2CeffHBnegativedirectionDigiD2 = new TH1F("h2CeffHBnegativedirectionDigiD2", "", nphi, 0., 72.);
4170 
4171  for (int jeta = 0; jeta < njeta; jeta++) {
4172  // negativedirectionDigiD:
4173  if (jeta - 41 < 0) {
4174  // for (int i=0;i<ndepth;i++) {
4175  // depth=2
4176  for (int i = 1; i < 2; i++) {
4177  TH1F *HBnegativedirectionDigiD2 = (TH1F *)h2CeffHBnegativedirectionDigiD2->Clone("twod1");
4178 
4179  float ccctest = 0; // to avoid empty massive elements
4180  for (int jphi = 0; jphi < nphi; jphi++) {
4181  double ccc1 = digivarianceHB[i][jeta][jphi];
4182  if (adigiHB[i][jeta][jphi] > 0.) {
4183  HBnegativedirectionDigiD2->Fill(jphi, ccc1);
4184  ccctest = 1.; //HBnegativedirectionDigiD2->SetBinError(i,0.01);
4185  }
4186  } // for jphi
4187  if (ccctest > 0.) {
4188  //cout<<"1515 kcountHBnegativedirectionDigiD2 = "<<kcountHBnegativedirectionDigiD2 <<" jeta-41= "<< jeta-41 <<endl;
4189  c3x5->cd(kcountHBnegativedirectionDigiD2);
4190  HBnegativedirectionDigiD2->SetMarkerStyle(20);
4191  HBnegativedirectionDigiD2->SetMarkerSize(0.4);
4192  HBnegativedirectionDigiD2->GetYaxis()->SetLabelSize(0.04);
4193  HBnegativedirectionDigiD2->SetXTitle("HBnegativedirectionDigiD2 \b");
4194  HBnegativedirectionDigiD2->SetMarkerColor(2);
4195  HBnegativedirectionDigiD2->SetLineColor(0);
4196  gPad->SetGridy();
4197  gPad->SetGridx();
4198  // gPad->SetLogy();
4199  if (kcountHBnegativedirectionDigiD2 == 1)
4200  HBnegativedirectionDigiD2->SetXTitle("D for HB- jeta =-16; depth = 2 \b");
4201  if (kcountHBnegativedirectionDigiD2 == 2)
4202  HBnegativedirectionDigiD2->SetXTitle("D for HB- jeta =-15; depth = 2 \b");
4203  if (kcountHBnegativedirectionDigiD2 == 3)
4204  HBnegativedirectionDigiD2->SetXTitle("D for HB- jeta =-14; depth = 2 \b");
4205  if (kcountHBnegativedirectionDigiD2 == 4)
4206  HBnegativedirectionDigiD2->SetXTitle("D for HB- jeta =-13; depth = 2 \b");
4207  if (kcountHBnegativedirectionDigiD2 == 5)
4208  HBnegativedirectionDigiD2->SetXTitle("D for HB- jeta =-12; depth = 2 \b");
4209  if (kcountHBnegativedirectionDigiD2 == 6)
4210  HBnegativedirectionDigiD2->SetXTitle("D for HB- jeta =-11; depth = 2 \b");
4211  if (kcountHBnegativedirectionDigiD2 == 7)
4212  HBnegativedirectionDigiD2->SetXTitle("D for HB- jeta =-10; depth = 2 \b");
4213  if (kcountHBnegativedirectionDigiD2 == 8)
4214  HBnegativedirectionDigiD2->SetXTitle("D for HB- jeta =-9; depth = 2 \b");
4215  if (kcountHBnegativedirectionDigiD2 == 9)
4216  HBnegativedirectionDigiD2->SetXTitle("D for HB- jeta =-8; depth = 2 \b");
4217  if (kcountHBnegativedirectionDigiD2 == 10)
4218  HBnegativedirectionDigiD2->SetXTitle("D for HB- jeta =-7; depth = 2 \b");
4219  if (kcountHBnegativedirectionDigiD2 == 11)
4220  HBnegativedirectionDigiD2->SetXTitle("D for HB- jeta =-6; depth = 2 \b");
4221  if (kcountHBnegativedirectionDigiD2 == 12)
4222  HBnegativedirectionDigiD2->SetXTitle("D for HB- jeta =-5; depth = 2 \b");
4223  if (kcountHBnegativedirectionDigiD2 == 13)
4224  HBnegativedirectionDigiD2->SetXTitle("D for HB- jeta =-4; depth = 2 \b");
4225  if (kcountHBnegativedirectionDigiD2 == 14)
4226  HBnegativedirectionDigiD2->SetXTitle("D for HB- jeta =-3; depth = 2 \b");
4227  if (kcountHBnegativedirectionDigiD2 == 15)
4228  HBnegativedirectionDigiD2->SetXTitle("D for HB- jeta =-2; depth = 2 \b");
4229  if (kcountHBnegativedirectionDigiD2 == 16)
4230  HBnegativedirectionDigiD2->SetXTitle("D for HB- jeta =-1; depth = 2 \b");
4231  HBnegativedirectionDigiD2->Draw("Error");
4232  kcountHBnegativedirectionDigiD2++;
4233  if (kcountHBnegativedirectionDigiD2 > 16)
4234  break; // 4x6 = 24
4235  } //ccctest>0
4236 
4237  } // for i
4238  } //if(jeta-41 < 0)
4239  } //for jeta
4241  c3x5->Update();
4242  c3x5->Print("DdigiNegativeDirectionhistD1PhiSymmetryDepth2HB.png");
4243  c3x5->Clear();
4244  // clean-up
4245  if (h2CeffHBnegativedirectionDigiD2)
4246  delete h2CeffHBnegativedirectionDigiD2;
4247  //========================================================================================== 22216
4248  //======================================================================
4249  //======================================================================1D plot: D vs phi , different eta, depth=3
4250  //cout<<" 1D plot: D vs phi , different eta, depth=3 *****" <<endl;
4251  c3x5->Clear();
4252  c3x5->Divide(4, 4);
4253  c3x5->cd(1);
4254  int kcountHBnegativedirectionDigiD3 = 1;
4255  TH1F *h2CeffHBnegativedirectionDigiD3 = new TH1F("h2CeffHBnegativedirectionDigiD3", "", nphi, 0., 72.);
4256 
4257  for (int jeta = 0; jeta < njeta; jeta++) {
4258  // negativedirectionDigiD:
4259  if (jeta - 41 < 0) {
4260  // for (int i=0;i<ndepth;i++) {
4261  // depth=3
4262  for (int i = 2; i < 3; i++) {
4263  TH1F *HBnegativedirectionDigiD3 = (TH1F *)h2CeffHBnegativedirectionDigiD3->Clone("twod1");
4264 
4265  float ccctest = 0; // to avoid empty massive elements
4266  for (int jphi = 0; jphi < nphi; jphi++) {
4267  double ccc1 = digivarianceHB[i][jeta][jphi];
4268  if (adigiHB[i][jeta][jphi] > 0.) {
4269  HBnegativedirectionDigiD3->Fill(jphi, ccc1);
4270  ccctest = 1.; //HBnegativedirectionDigiD3->SetBinError(i,0.01);
4271  }
4272  } // for jphi
4273  if (ccctest > 0.) {
4274  //cout<<"1616 kcountHBnegativedirectionDigiD3 = "<<kcountHBnegativedirectionDigiD3 <<" jeta-41= "<< jeta-41 <<endl;
4275  c3x5->cd(kcountHBnegativedirectionDigiD3);
4276  HBnegativedirectionDigiD3->SetMarkerStyle(20);
4277  HBnegativedirectionDigiD3->SetMarkerSize(0.4);
4278  HBnegativedirectionDigiD3->GetYaxis()->SetLabelSize(0.04);
4279  HBnegativedirectionDigiD3->SetXTitle("HBnegativedirectionDigiD3 \b");
4280  HBnegativedirectionDigiD3->SetMarkerColor(2);
4281  HBnegativedirectionDigiD3->SetLineColor(0);
4282  gPad->SetGridy();
4283  gPad->SetGridx();
4284  // gPad->SetLogy();
4285  if (kcountHBnegativedirectionDigiD3 == 1)
4286  HBnegativedirectionDigiD3->SetXTitle("D for HB- jeta =-16; depth = 3 \b");
4287  if (kcountHBnegativedirectionDigiD3 == 2)
4288  HBnegativedirectionDigiD3->SetXTitle("D for HB- jeta =-15; depth = 3 \b");
4289  if (kcountHBnegativedirectionDigiD3 == 3)
4290  HBnegativedirectionDigiD3->SetXTitle("D for HB- jeta =-14; depth = 3 \b");
4291  if (kcountHBnegativedirectionDigiD3 == 4)
4292  HBnegativedirectionDigiD3->SetXTitle("D for HB- jeta =-13; depth = 3 \b");
4293  if (kcountHBnegativedirectionDigiD3 == 5)
4294  HBnegativedirectionDigiD3->SetXTitle("D for HB- jeta =-12; depth = 3 \b");
4295  if (kcountHBnegativedirectionDigiD3 == 6)
4296  HBnegativedirectionDigiD3->SetXTitle("D for HB- jeta =-11; depth = 3 \b");
4297  if (kcountHBnegativedirectionDigiD3 == 7)
4298  HBnegativedirectionDigiD3->SetXTitle("D for HB- jeta =-10; depth = 3 \b");
4299  if (kcountHBnegativedirectionDigiD3 == 8)
4300  HBnegativedirectionDigiD3->SetXTitle("D for HB- jeta =-9; depth = 3 \b");
4301  if (kcountHBnegativedirectionDigiD3 == 9)
4302  HBnegativedirectionDigiD3->SetXTitle("D for HB- jeta =-8; depth = 3 \b");
4303  if (kcountHBnegativedirectionDigiD3 == 10)
4304  HBnegativedirectionDigiD3->SetXTitle("D for HB- jeta =-7; depth = 3 \b");
4305  if (kcountHBnegativedirectionDigiD3 == 11)
4306  HBnegativedirectionDigiD3->SetXTitle("D for HB- jeta =-6; depth = 3 \b");
4307  if (kcountHBnegativedirectionDigiD3 == 12)
4308  HBnegativedirectionDigiD3->SetXTitle("D for HB- jeta =-5; depth = 3 \b");
4309  if (kcountHBnegativedirectionDigiD3 == 13)
4310  HBnegativedirectionDigiD3->SetXTitle("D for HB- jeta =-4; depth = 3 \b");
4311  if (kcountHBnegativedirectionDigiD3 == 14)
4312  HBnegativedirectionDigiD3->SetXTitle("D for HB- jeta =-3; depth = 3 \b");
4313  if (kcountHBnegativedirectionDigiD3 == 15)
4314  HBnegativedirectionDigiD3->SetXTitle("D for HB- jeta =-2; depth = 3 \b");
4315  if (kcountHBnegativedirectionDigiD3 == 16)
4316  HBnegativedirectionDigiD3->SetXTitle("D for HB- jeta =-1; depth = 3 \b");
4317  HBnegativedirectionDigiD3->Draw("Error");
4318  kcountHBnegativedirectionDigiD3++;
4319  if (kcountHBnegativedirectionDigiD3 > 16)
4320  break; // 4x6 = 24
4321  } //ccctest>0
4322 
4323  } // for i
4324  } //if(jeta-41 < 0)
4325  } //for jeta
4327  c3x5->Update();
4328  c3x5->Print("DdigiNegativeDirectionhistD1PhiSymmetryDepth3HB.png");
4329  c3x5->Clear();
4330  // clean-up
4331  if (h2CeffHBnegativedirectionDigiD3)
4332  delete h2CeffHBnegativedirectionDigiD3;
4333  //========================================================================================== 22217
4334  //======================================================================
4335  //======================================================================1D plot: D vs phi , different eta, depth=4
4336  //cout<<" 1D plot: D vs phi , different eta, depth=4 *****" <<endl;
4337  c3x5->Clear();
4338  c3x5->Divide(4, 4);
4339  c3x5->cd(1);
4340  int kcountHBnegativedirectionDigiD4 = 1;
4341  TH1F *h2CeffHBnegativedirectionDigiD4 = new TH1F("h2CeffHBnegativedirectionDigiD4", "", nphi, 0., 72.);
4342 
4343  for (int jeta = 0; jeta < njeta; jeta++) {
4344  // negativedirectionDigiD:
4345  if (jeta - 41 < 0) {
4346  // for (int i=0;i<ndepth;i++) {
4347  // depth=4
4348  for (int i = 3; i < 4; i++) {
4349  TH1F *HBnegativedirectionDigiD4 = (TH1F *)h2CeffHBnegativedirectionDigiD4->Clone("twod1");
4350 
4351  float ccctest = 0; // to avoid empty massive elements
4352  for (int jphi = 0; jphi < nphi; jphi++) {
4353  double ccc1 = digivarianceHB[i][jeta][jphi];
4354  if (adigiHB[i][jeta][jphi] > 0.) {
4355  HBnegativedirectionDigiD4->Fill(jphi, ccc1);
4356  ccctest = 1.; //HBnegativedirectionDigiD4->SetBinError(i,0.01);
4357  }
4358  } // for jphi
4359  if (ccctest > 0.) {
4360  //cout<<"1717 kcountHBnegativedirectionDigiD4 = "<<kcountHBnegativedirectionDigiD4 <<" jeta-41= "<< jeta-41 <<endl;
4361  c3x5->cd(kcountHBnegativedirectionDigiD4);
4362  HBnegativedirectionDigiD4->SetMarkerStyle(20);
4363  HBnegativedirectionDigiD4->SetMarkerSize(0.4);
4364  HBnegativedirectionDigiD4->GetYaxis()->SetLabelSize(0.04);
4365  HBnegativedirectionDigiD4->SetXTitle("HBnegativedirectionDigiD4 \b");
4366  HBnegativedirectionDigiD4->SetMarkerColor(2);
4367  HBnegativedirectionDigiD4->SetLineColor(0);
4368  gPad->SetGridy();
4369  gPad->SetGridx();
4370  // gPad->SetLogy();
4371  if (kcountHBnegativedirectionDigiD4 == 1)
4372  HBnegativedirectionDigiD4->SetXTitle("D for HB- jeta =-16; depth = 4 \b");
4373  if (kcountHBnegativedirectionDigiD4 == 2)
4374  HBnegativedirectionDigiD4->SetXTitle("D for HB- jeta =-15; depth = 4 \b");
4375  if (kcountHBnegativedirectionDigiD4 == 3)
4376  HBnegativedirectionDigiD4->SetXTitle("D for HB- jeta =-14; depth = 4 \b");
4377  if (kcountHBnegativedirectionDigiD4 == 4)
4378  HBnegativedirectionDigiD4->SetXTitle("D for HB- jeta =-13; depth = 4 \b");
4379  if (kcountHBnegativedirectionDigiD4 == 5)
4380  HBnegativedirectionDigiD4->SetXTitle("D for HB- jeta =-12; depth = 4 \b");
4381  if (kcountHBnegativedirectionDigiD4 == 6)
4382  HBnegativedirectionDigiD4->SetXTitle("D for HB- jeta =-11; depth = 4 \b");
4383  if (kcountHBnegativedirectionDigiD4 == 7)
4384  HBnegativedirectionDigiD4->SetXTitle("D for HB- jeta =-10; depth = 4 \b");
4385  if (kcountHBnegativedirectionDigiD4 == 8)
4386  HBnegativedirectionDigiD4->SetXTitle("D for HB- jeta =-9; depth = 4 \b");
4387  if (kcountHBnegativedirectionDigiD4 == 9)
4388  HBnegativedirectionDigiD4->SetXTitle("D for HB- jeta =-8; depth = 4 \b");
4389  if (kcountHBnegativedirectionDigiD4 == 10)
4390  HBnegativedirectionDigiD4->SetXTitle("D for HB- jeta =-7; depth = 4 \b");
4391  if (kcountHBnegativedirectionDigiD4 == 11)
4392  HBnegativedirectionDigiD4->SetXTitle("D for HB- jeta =-6; depth = 4 \b");
4393  if (kcountHBnegativedirectionDigiD4 == 12)
4394  HBnegativedirectionDigiD4->SetXTitle("D for HB- jeta =-5; depth = 4 \b");
4395  if (kcountHBnegativedirectionDigiD4 == 13)
4396  HBnegativedirectionDigiD4->SetXTitle("D for HB- jeta =-4; depth = 4 \b");
4397  if (kcountHBnegativedirectionDigiD4 == 14)
4398  HBnegativedirectionDigiD4->SetXTitle("D for HB- jeta =-3; depth = 4 \b");
4399  if (kcountHBnegativedirectionDigiD4 == 15)
4400  HBnegativedirectionDigiD4->SetXTitle("D for HB- jeta =-2; depth = 4 \b");
4401  if (kcountHBnegativedirectionDigiD4 == 16)
4402  HBnegativedirectionDigiD4->SetXTitle("D for HB- jeta =-1; depth = 4 \b");
4403  HBnegativedirectionDigiD4->Draw("Error");
4404  kcountHBnegativedirectionDigiD4++;
4405  if (kcountHBnegativedirectionDigiD4 > 16)
4406  break; // 4x6 = 24
4407  } //ccctest>0
4408 
4409  } // for i
4410  } //if(jeta-41 < 0)
4411  } //for jeta
4413  c3x5->Update();
4414  c3x5->Print("DdigiNegativeDirectionhistD1PhiSymmetryDepth4HB.png");
4415  c3x5->Clear();
4416  // clean-up
4417  if (h2CeffHBnegativedirectionDigiD4)
4418  delete h2CeffHBnegativedirectionDigiD4;
4419 
4420  //===================================================================== END of Digi HB for phi-symmetry
4421  //===================================================================== END of Digi HB for phi-symmetry
4422  //===================================================================== END of Digi HB for phi-symmetry
4423 
4427  // int k_max[5]={0,4,7,4,4}; // maximum depth for each subdet
4428  //ndepth = k_max[3];
4429  ndepth = 7;
4430  // const int ndepth = 7;
4431  double adigihe[ndepth][njeta][njphi];
4432  double digivariancehe[ndepth][njeta][njphi];
4433  // RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR: Digi HE
4434  TH2F *amplitudechannel1HE1 = (TH2F *)dir->FindObjectAny("h_amplitudechannel1_HE1");
4435  TH2F *amplitudechannel0HE1 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HE1");
4436  TH2F *amplitudechannelHE1 = (TH2F *)amplitudechannel1HE1->Clone("amplitudechannelHE1");
4437  amplitudechannelHE1->Divide(amplitudechannel1HE1, amplitudechannel0HE1, 1, 1, "B");
4438  TH2F *amplitudechannel1HE2 = (TH2F *)dir->FindObjectAny("h_amplitudechannel1_HE2");
4439  TH2F *amplitudechannel0HE2 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HE2");
4440  TH2F *amplitudechannelHE2 = (TH2F *)amplitudechannel1HE2->Clone("amplitudechannelHE2");
4441  amplitudechannelHE2->Divide(amplitudechannel1HE2, amplitudechannel0HE2, 1, 1, "B");
4442  TH2F *amplitudechannel1HE3 = (TH2F *)dir->FindObjectAny("h_amplitudechannel1_HE3");
4443  TH2F *amplitudechannel0HE3 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HE3");
4444  TH2F *amplitudechannelHE3 = (TH2F *)amplitudechannel1HE3->Clone("amplitudechannelHE3");
4445  amplitudechannelHE3->Divide(amplitudechannel1HE3, amplitudechannel0HE3, 1, 1, "B");
4446  TH2F *amplitudechannel1HE4 = (TH2F *)dir->FindObjectAny("h_amplitudechannel1_HE4");
4447  TH2F *amplitudechannel0HE4 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HE4");
4448  TH2F *amplitudechannelHE4 = (TH2F *)amplitudechannel1HE4->Clone("amplitudechannelHE4");
4449  amplitudechannelHE4->Divide(amplitudechannel1HE4, amplitudechannel0HE4, 1, 1, "B");
4450  TH2F *amplitudechannel1HE5 = (TH2F *)dir->FindObjectAny("h_amplitudechannel1_HE5");
4451  TH2F *amplitudechannel0HE5 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HE5");
4452  TH2F *amplitudechannelHE5 = (TH2F *)amplitudechannel1HE5->Clone("amplitudechannelHE5");
4453  amplitudechannelHE5->Divide(amplitudechannel1HE5, amplitudechannel0HE5, 1, 1, "B");
4454  TH2F *amplitudechannel1HE6 = (TH2F *)dir->FindObjectAny("h_amplitudechannel1_HE6");
4455  TH2F *amplitudechannel0HE6 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HE6");
4456  TH2F *amplitudechannelHE6 = (TH2F *)amplitudechannel1HE6->Clone("amplitudechannelHE6");
4457  amplitudechannelHE6->Divide(amplitudechannel1HE6, amplitudechannel0HE6, 1, 1, "B");
4458  TH2F *amplitudechannel1HE7 = (TH2F *)dir->FindObjectAny("h_amplitudechannel1_HE7");
4459  TH2F *amplitudechannel0HE7 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HE7");
4460  TH2F *amplitudechannelHE7 = (TH2F *)amplitudechannel1HE7->Clone("amplitudechannelHE7");
4461  amplitudechannelHE7->Divide(amplitudechannel1HE7, amplitudechannel0HE7, 1, 1, "B");
4462  for (int jeta = 0; jeta < njeta; jeta++) {
4463  //====================================================================== PHI normalization & put R into massive adigihe
4464  //preparation for PHI normalization:
4465  double sumdigiHE0 = 0;
4466  int nsumdigiHE0 = 0;
4467  double sumdigiHE1 = 0;
4468  int nsumdigiHE1 = 0;
4469  double sumdigiHE2 = 0;
4470  int nsumdigiHE2 = 0;
4471  double sumdigiHE3 = 0;
4472  int nsumdigiHE3 = 0;
4473  double sumdigiHE4 = 0;
4474  int nsumdigiHE4 = 0;
4475  double sumdigiHE5 = 0;
4476  int nsumdigiHE5 = 0;
4477  double sumdigiHE6 = 0;
4478  int nsumdigiHE6 = 0;
4479  for (int jphi = 0; jphi < njphi; jphi++) {
4480  adigihe[0][jeta][jphi] = amplitudechannelHE1->GetBinContent(jeta + 1, jphi + 1);
4481  adigihe[1][jeta][jphi] = amplitudechannelHE2->GetBinContent(jeta + 1, jphi + 1);
4482  adigihe[2][jeta][jphi] = amplitudechannelHE3->GetBinContent(jeta + 1, jphi + 1);
4483  adigihe[3][jeta][jphi] = amplitudechannelHE4->GetBinContent(jeta + 1, jphi + 1);
4484  adigihe[4][jeta][jphi] = amplitudechannelHE5->GetBinContent(jeta + 1, jphi + 1);
4485  adigihe[5][jeta][jphi] = amplitudechannelHE6->GetBinContent(jeta + 1, jphi + 1);
4486  adigihe[6][jeta][jphi] = amplitudechannelHE7->GetBinContent(jeta + 1, jphi + 1);
4487  if (adigihe[0][jeta][jphi] > 0.) {
4488  sumdigiHE0 += adigihe[0][jeta][jphi];
4489  ++nsumdigiHE0;
4490  }
4491  if (adigihe[1][jeta][jphi] > 0.) {
4492  sumdigiHE1 += adigihe[1][jeta][jphi];
4493  ++nsumdigiHE1;
4494  }
4495  if (adigihe[2][jeta][jphi] > 0.) {
4496  sumdigiHE2 += adigihe[2][jeta][jphi];
4497  ++nsumdigiHE2;
4498  }
4499  if (adigihe[3][jeta][jphi] > 0.) {
4500  sumdigiHE3 += adigihe[3][jeta][jphi];
4501  ++nsumdigiHE3;
4502  }
4503  if (adigihe[4][jeta][jphi] > 0.) {
4504  sumdigiHE4 += adigihe[4][jeta][jphi];
4505  ++nsumdigiHE4;
4506  }
4507  if (adigihe[5][jeta][jphi] > 0.) {
4508  sumdigiHE5 += adigihe[5][jeta][jphi];
4509  ++nsumdigiHE5;
4510  }
4511  if (adigihe[6][jeta][jphi] > 0.) {
4512  sumdigiHE6 += adigihe[6][jeta][jphi];
4513  ++nsumdigiHE6;
4514  }
4515  } // phi
4516  // PHI normalization:
4517  for (int jphi = 0; jphi < njphi; jphi++) {
4518  if (adigihe[0][jeta][jphi] > 0.)
4519  adigihe[0][jeta][jphi] /= (sumdigiHE0 / nsumdigiHE0);
4520  if (adigihe[1][jeta][jphi] > 0.)
4521  adigihe[1][jeta][jphi] /= (sumdigiHE1 / nsumdigiHE1);
4522  if (adigihe[2][jeta][jphi] > 0.)
4523  adigihe[2][jeta][jphi] /= (sumdigiHE2 / nsumdigiHE2);
4524  if (adigihe[3][jeta][jphi] > 0.)
4525  adigihe[3][jeta][jphi] /= (sumdigiHE3 / nsumdigiHE3);
4526  if (adigihe[4][jeta][jphi] > 0.)
4527  adigihe[4][jeta][jphi] /= (sumdigiHE4 / nsumdigiHE4);
4528  if (adigihe[5][jeta][jphi] > 0.)
4529  adigihe[5][jeta][jphi] /= (sumdigiHE5 / nsumdigiHE5);
4530  if (adigihe[6][jeta][jphi] > 0.)
4531  adigihe[6][jeta][jphi] /= (sumdigiHE6 / nsumdigiHE6);
4532  } // phi
4533  } //eta
4534  //------------------------ 2D-eta/phi-plot: R, averaged over depthes
4535  //======================================================================
4536  //======================================================================
4537  //cout<<" R2D-eta/phi-plot: R, averaged over depthes *****" <<endl;
4538  c1x0->Clear();
4540  c1x0->Divide(1, 1);
4541  c1x0->cd(1);
4542  TH2F *GefzRdigiHE42D = new TH2F("GefzRdigiHE42D", "", neta, -41., 41., nphi, 0., 72.);
4543  TH2F *GefzRdigiHE42D0 = new TH2F("GefzRdigiHE42D0", "", neta, -41., 41., nphi, 0., 72.);
4544  TH2F *GefzRdigiHE42DF = (TH2F *)GefzRdigiHE42D0->Clone("GefzRdigiHE42DF");
4545  for (int i = 0; i < ndepth; i++) {
4546  for (int jeta = 0; jeta < neta; jeta++) {
4547  for (int jphi = 0; jphi < nphi; jphi++) {
4548  double ccc1 = adigihe[i][jeta][jphi];
4549  int k2plot = jeta - 41;
4550  int kkk = k2plot; //if(k2plot >0 ) kkk=k2plot+1; //-41 +41 !=0
4551  if (ccc1 != 0.) {
4552  GefzRdigiHE42D->Fill(kkk, jphi, ccc1);
4553  GefzRdigiHE42D0->Fill(kkk, jphi, 1.);
4554  }
4555  }
4556  }
4557  }
4558  GefzRdigiHE42DF->Divide(GefzRdigiHE42D, GefzRdigiHE42D0, 1, 1, "B"); // average A
4559  gPad->SetGridy();
4560  gPad->SetGridx(); // gPad->SetLogz();
4561  GefzRdigiHE42DF->SetMarkerStyle(20);
4562  GefzRdigiHE42DF->SetMarkerSize(0.4);
4563  GefzRdigiHE42DF->GetZaxis()->SetLabelSize(0.08);
4564  GefzRdigiHE42DF->SetXTitle("<R>_depth #eta \b");
4565  GefzRdigiHE42DF->SetYTitle(" #phi \b");
4566  GefzRdigiHE42DF->SetZTitle("<R>_depth \b");
4567  GefzRdigiHE42DF->SetMarkerColor(2);
4568  GefzRdigiHE42DF->SetLineColor(
4569  0); // GefzRdigiHE42DF->SetMaximum(1.000); // GefzRdigiHE42DF->SetMinimum(1.0);
4570  GefzRdigiHE42DF->Draw("COLZ");
4572  c1x0->Update();
4573  c1x0->Print("RdigiGeneralD2PhiSymmetryHE.png");
4574  c1x0->Clear();
4575  // clean-up
4576  if (GefzRdigiHE42D)
4577  delete GefzRdigiHE42D;
4578  if (GefzRdigiHE42D0)
4579  delete GefzRdigiHE42D0;
4580  if (GefzRdigiHE42DF)
4581  delete GefzRdigiHE42DF;
4582  //====================================================================== 1D plot: R vs phi , averaged over depthes & eta
4583  //======================================================================
4584  //cout<<" 1D plot: R vs phi , averaged over depthes & eta *****" <<endl;
4585  c1x1->Clear();
4587  c1x1->Divide(1, 1);
4588  c1x1->cd(1);
4589  TH1F *GefzRdigiHE41D = new TH1F("GefzRdigiHE41D", "", nphi, 0., 72.);
4590  TH1F *GefzRdigiHE41D0 = new TH1F("GefzRdigiHE41D0", "", nphi, 0., 72.);
4591  TH1F *GefzRdigiHE41DF = (TH1F *)GefzRdigiHE41D0->Clone("GefzRdigiHE41DF");
4592  for (int jphi = 0; jphi < nphi; jphi++) {
4593  for (int jeta = 0; jeta < neta; jeta++) {
4594  for (int i = 0; i < ndepth; i++) {
4595  double ccc1 = adigihe[i][jeta][jphi];
4596  if (ccc1 != 0.) {
4597  GefzRdigiHE41D->Fill(jphi, ccc1);
4598  GefzRdigiHE41D0->Fill(jphi, 1.);
4599  }
4600  }
4601  }
4602  }
4603  GefzRdigiHE41DF->Divide(GefzRdigiHE41D, GefzRdigiHE41D0, 1, 1, "B"); // R averaged over depthes & eta
4604  GefzRdigiHE41D0->Sumw2();
4605  // for (int jphi=1;jphi<73;jphi++) {GefzRdigiHE41DF->SetBinError(jphi,0.01);}
4606  gPad->SetGridy();
4607  gPad->SetGridx(); // gPad->SetLogz();
4608  GefzRdigiHE41DF->SetMarkerStyle(20);
4609  GefzRdigiHE41DF->SetMarkerSize(1.4);
4610  GefzRdigiHE41DF->GetZaxis()->SetLabelSize(0.08);
4611  GefzRdigiHE41DF->SetXTitle("#phi \b");
4612  GefzRdigiHE41DF->SetYTitle(" <R> \b");
4613  GefzRdigiHE41DF->SetZTitle("<R>_PHI - AllDepthes \b");
4614  GefzRdigiHE41DF->SetMarkerColor(4);
4615  GefzRdigiHE41DF->SetLineColor(
4616  4); // GefzRdigiHE41DF->SetMinimum(0.8); // GefzRdigiHE41DF->SetMaximum(1.000);
4617  GefzRdigiHE41DF->Draw("Error");
4619  c1x1->Update();
4620  c1x1->Print("RdigiGeneralD1PhiSymmetryHE.png");
4621  c1x1->Clear();
4622  // clean-up
4623  if (GefzRdigiHE41D)
4624  delete GefzRdigiHE41D;
4625  if (GefzRdigiHE41D0)
4626  delete GefzRdigiHE41D0;
4627  if (GefzRdigiHE41DF)
4628  delete GefzRdigiHE41DF;
4629 
4630  //========================================================================================== 4
4631  //======================================================================
4632  //======================================================================1D plot: R vs phi , different eta, depth=1
4633  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
4634  c3x5->Clear();
4636  c3x5->Divide(3, 5);
4637  c3x5->cd(1);
4638  int kcountHEpositivedirectionDigi1 = 1;
4639  TH1F *h2CeffHEpositivedirectionDigi1 = new TH1F("h2CeffHEpositivedirectionDigi1", "", nphi, 0., 72.);
4640  for (int jeta = 0; jeta < njeta; jeta++) {
4641  // positivedirectionDigi:
4642  if (jeta - 41 >= 0) {
4643  // for (int i=0;i<ndepth;i++) {
4644  // depth=1
4645  for (int i = 0; i < 1; i++) {
4646  TH1F *HEpositivedirectionDigi1 = (TH1F *)h2CeffHEpositivedirectionDigi1->Clone("twod1");
4647  float ccctest = 0; // to avoid empty massive elements
4648  for (int jphi = 0; jphi < nphi; jphi++) {
4649  double ccc1 = adigihe[i][jeta][jphi];
4650  if (ccc1 != 0.) {
4651  HEpositivedirectionDigi1->Fill(jphi, ccc1);
4652  ccctest = 1.; //HEpositivedirectionDigi1->SetBinError(i,0.01);
4653  }
4654  } // for jphi
4655  if (ccctest > 0.) {
4656  // cout<<"444 kcountHEpositivedirectionDigi1 = "<<kcountHEpositivedirectionDigi1 <<" jeta-41= "<< jeta-41 <<endl;
4657  c3x5->cd(kcountHEpositivedirectionDigi1);
4658  HEpositivedirectionDigi1->SetMarkerStyle(20);
4659  HEpositivedirectionDigi1->SetMarkerSize(0.4);
4660  HEpositivedirectionDigi1->GetYaxis()->SetLabelSize(0.04);
4661  HEpositivedirectionDigi1->SetXTitle("HEpositivedirectionDigi1 \b");
4662  HEpositivedirectionDigi1->SetMarkerColor(2);
4663  HEpositivedirectionDigi1->SetLineColor(0);
4664  gPad->SetGridy();
4665  gPad->SetGridx();
4666  // gPad->SetLogy();
4667  if (kcountHEpositivedirectionDigi1 == 1)
4668  HEpositivedirectionDigi1->SetXTitle("R for HE+ jeta = 17; depth = 1 \b");
4669  if (kcountHEpositivedirectionDigi1 == 2)
4670  HEpositivedirectionDigi1->SetXTitle("R for HE+ jeta = 18; depth = 1 \b");
4671  if (kcountHEpositivedirectionDigi1 == 3)
4672  HEpositivedirectionDigi1->SetXTitle("R for HE+ jeta = 19; depth = 1 \b");
4673  if (kcountHEpositivedirectionDigi1 == 4)
4674  HEpositivedirectionDigi1->SetXTitle("R for HE+ jeta = 20; depth = 1 \b");
4675  if (kcountHEpositivedirectionDigi1 == 5)
4676  HEpositivedirectionDigi1->SetXTitle("R for HE+ jeta = 21; depth = 1 \b");
4677  if (kcountHEpositivedirectionDigi1 == 6)
4678  HEpositivedirectionDigi1->SetXTitle("R for HE+ jeta = 22; depth = 1 \b");
4679  if (kcountHEpositivedirectionDigi1 == 7)
4680  HEpositivedirectionDigi1->SetXTitle("R for HE+ jeta = 23; depth = 1 \b");
4681  if (kcountHEpositivedirectionDigi1 == 8)
4682  HEpositivedirectionDigi1->SetXTitle("R for HE+ jeta = 24; depth = 1 \b");
4683  if (kcountHEpositivedirectionDigi1 == 9)
4684  HEpositivedirectionDigi1->SetXTitle("R for HE+ jeta = 25; depth = 1 \b");
4685  if (kcountHEpositivedirectionDigi1 == 10)
4686  HEpositivedirectionDigi1->SetXTitle("R for HE+ jeta = 26; depth = 1 \b");
4687  if (kcountHEpositivedirectionDigi1 == 11)
4688  HEpositivedirectionDigi1->SetXTitle("R for HE+ jeta = 27; depth = 1 \b");
4689  if (kcountHEpositivedirectionDigi1 == 12)
4690  HEpositivedirectionDigi1->SetXTitle("R for HE+ jeta = 28; depth = 1 \b");
4691  HEpositivedirectionDigi1->Draw("Error");
4692  kcountHEpositivedirectionDigi1++;
4693  if (kcountHEpositivedirectionDigi1 > 12)
4694  break; // 4x6 = 24
4695  } //ccctest>0
4696 
4697  } // for i
4698  } //if(jeta-41 >= 0)
4699  } //for jeta
4701  c3x5->Update();
4702  c3x5->Print("RdigiPositiveDirectionhistD1PhiSymmetryDepth1HE.png");
4703  c3x5->Clear();
4704  // clean-up
4705  if (h2CeffHEpositivedirectionDigi1)
4706  delete h2CeffHEpositivedirectionDigi1;
4707 
4708  //========================================================================================== 5
4709  //======================================================================
4710  //======================================================================1D plot: R vs phi , different eta, depth=2
4711  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
4712  c3x5->Clear();
4714  c3x5->Divide(3, 5);
4715  c3x5->cd(1);
4716  int kcountHEpositivedirectionDigi2 = 1;
4717  TH1F *h2CeffHEpositivedirectionDigi2 = new TH1F("h2CeffHEpositivedirectionDigi2", "", nphi, 0., 72.);
4718  for (int jeta = 0; jeta < njeta; jeta++) {
4719  // positivedirectionDigi:
4720  if (jeta - 41 >= 0) {
4721  // for (int i=0;i<ndepth;i++) {
4722  // depth=2
4723  for (int i = 1; i < 2; i++) {
4724  TH1F *HEpositivedirectionDigi2 = (TH1F *)h2CeffHEpositivedirectionDigi2->Clone("twod1");
4725  float ccctest = 0; // to avoid empty massive elements
4726  for (int jphi = 0; jphi < nphi; jphi++) {
4727  double ccc1 = adigihe[i][jeta][jphi];
4728  if (ccc1 != 0.) {
4729  HEpositivedirectionDigi2->Fill(jphi, ccc1);
4730  ccctest = 1.; //HEpositivedirectionDigi2->SetBinError(i,0.01);
4731  }
4732  } // for jphi
4733  if (ccctest > 0.) {
4734  //cout<<"555 kcountHEpositivedirectionDigi2 = "<<kcountHEpositivedirectionDigi2 <<" jeta-41= "<< jeta-41 <<endl;
4735  c3x5->cd(kcountHEpositivedirectionDigi2);
4736  HEpositivedirectionDigi2->SetMarkerStyle(20);
4737  HEpositivedirectionDigi2->SetMarkerSize(0.4);
4738  HEpositivedirectionDigi2->GetYaxis()->SetLabelSize(0.04);
4739  HEpositivedirectionDigi2->SetXTitle("HEpositivedirectionDigi2 \b");
4740  HEpositivedirectionDigi2->SetMarkerColor(2);
4741  HEpositivedirectionDigi2->SetLineColor(0);
4742  gPad->SetGridy();
4743  gPad->SetGridx();
4744  // gPad->SetLogy();
4745  if (kcountHEpositivedirectionDigi2 == 1)
4746  HEpositivedirectionDigi2->SetXTitle("R for HE+ jeta = 16; depth = 2 \b");
4747  if (kcountHEpositivedirectionDigi2 == 2)
4748  HEpositivedirectionDigi2->SetXTitle("R for HE+ jeta = 17; depth = 2 \b");
4749  if (kcountHEpositivedirectionDigi2 == 3)
4750  HEpositivedirectionDigi2->SetXTitle("R for HE+ jeta = 18; depth = 2 \b");
4751  if (kcountHEpositivedirectionDigi2 == 4)
4752  HEpositivedirectionDigi2->SetXTitle("R for HE+ jeta = 19; depth = 2 \b");
4753  if (kcountHEpositivedirectionDigi2 == 5)
4754  HEpositivedirectionDigi2->SetXTitle("R for HE+ jeta = 20; depth = 2 \b");
4755  if (kcountHEpositivedirectionDigi2 == 6)
4756  HEpositivedirectionDigi2->SetXTitle("R for HE+ jeta = 21; depth = 2 \b");
4757  if (kcountHEpositivedirectionDigi2 == 7)
4758  HEpositivedirectionDigi2->SetXTitle("R for HE+ jeta = 22; depth = 2 \b");
4759  if (kcountHEpositivedirectionDigi2 == 8)
4760  HEpositivedirectionDigi2->SetXTitle("R for HE+ jeta = 23; depth = 2 \b");
4761  if (kcountHEpositivedirectionDigi2 == 9)
4762  HEpositivedirectionDigi2->SetXTitle("R for HE+ jeta = 24; depth = 2 \b");
4763  if (kcountHEpositivedirectionDigi2 == 10)
4764  HEpositivedirectionDigi2->SetXTitle("R for HE+ jeta = 25; depth = 2 \b");
4765  if (kcountHEpositivedirectionDigi2 == 11)
4766  HEpositivedirectionDigi2->SetXTitle("R for HE+ jeta = 26; depth = 2 \b");
4767  if (kcountHEpositivedirectionDigi2 == 12)
4768  HEpositivedirectionDigi2->SetXTitle("R for HE+ jeta = 27; depth = 2 \b");
4769  if (kcountHEpositivedirectionDigi2 == 13)
4770  HEpositivedirectionDigi2->SetXTitle("R for HE+ jeta = 28; depth = 2 \b");
4771  HEpositivedirectionDigi2->Draw("Error");
4772  kcountHEpositivedirectionDigi2++;
4773  if (kcountHEpositivedirectionDigi2 > 13)
4774  break; // 4x6 = 24
4775  } //ccctest>0
4776 
4777  } // for i
4778  } //if(jeta-41 >= 0)
4779  } //for jeta
4781  c3x5->Update();
4782  c3x5->Print("RdigiPositiveDirectionhistD1PhiSymmetryDepth2HE.png");
4783  c3x5->Clear();
4784  // clean-up
4785  if (h2CeffHEpositivedirectionDigi2)
4786  delete h2CeffHEpositivedirectionDigi2;
4787  //========================================================================================== 6
4788  //======================================================================
4789  //======================================================================1D plot: R vs phi , different eta, depth=3
4790  //cout<<" 1D plot: R vs phi , different eta, depth=3 *****" <<endl;
4791  c3x5->Clear();
4793  c3x5->Divide(3, 5);
4794  c3x5->cd(1);
4795  int kcountHEpositivedirectionDigi3 = 1;
4796  TH1F *h2CeffHEpositivedirectionDigi3 = new TH1F("h2CeffHEpositivedirectionDigi3", "", nphi, 0., 72.);
4797  for (int jeta = 0; jeta < njeta; jeta++) {
4798  // positivedirectionDigi:
4799  if (jeta - 41 >= 0) {
4800  // for (int i=0;i<ndepth;i++) {
4801  // depth=3
4802  for (int i = 2; i < 3; i++) {
4803  TH1F *HEpositivedirectionDigi3 = (TH1F *)h2CeffHEpositivedirectionDigi3->Clone("twod1");
4804  float ccctest = 0; // to avoid empty massive elements
4805  for (int jphi = 0; jphi < nphi; jphi++) {
4806  double ccc1 = adigihe[i][jeta][jphi];
4807  if (ccc1 != 0.) {
4808  HEpositivedirectionDigi3->Fill(jphi, ccc1);
4809  ccctest = 1.; //HEpositivedirectionDigi3->SetBinError(i,0.01);
4810  }
4811  } // for jphi
4812  if (ccctest > 0.) {
4813  //cout<<"666 kcountHEpositivedirectionDigi3 = "<<kcountHEpositivedirectionDigi3 <<" jeta-41= "<< jeta-41 <<endl;
4814  c3x5->cd(kcountHEpositivedirectionDigi3);
4815  HEpositivedirectionDigi3->SetMarkerStyle(20);
4816  HEpositivedirectionDigi3->SetMarkerSize(0.4);
4817  HEpositivedirectionDigi3->GetYaxis()->SetLabelSize(0.04);
4818  HEpositivedirectionDigi3->SetXTitle("HEpositivedirectionDigi3 \b");
4819  HEpositivedirectionDigi3->SetMarkerColor(2);
4820  HEpositivedirectionDigi3->SetLineColor(0);
4821  gPad->SetGridy();
4822  gPad->SetGridx();
4823  // gPad->SetLogy();
4824  if (kcountHEpositivedirectionDigi3 == 1)
4825  HEpositivedirectionDigi3->SetXTitle("R for HE+ jeta = 16; depth = 3 \b");
4826  if (kcountHEpositivedirectionDigi3 == 2)
4827  HEpositivedirectionDigi3->SetXTitle("R for HE+ jeta = 17; depth = 3 \b");
4828  if (kcountHEpositivedirectionDigi3 == 3)
4829  HEpositivedirectionDigi3->SetXTitle("R for HE+ jeta = 18; depth = 3 \b");
4830  if (kcountHEpositivedirectionDigi3 == 4)
4831  HEpositivedirectionDigi3->SetXTitle("R for HE+ jeta = 19; depth = 3 \b");
4832  if (kcountHEpositivedirectionDigi3 == 5)
4833  HEpositivedirectionDigi3->SetXTitle("R for HE+ jeta = 20; depth = 3 \b");
4834  if (kcountHEpositivedirectionDigi3 == 6)
4835  HEpositivedirectionDigi3->SetXTitle("R for HE+ jeta = 21; depth = 3 \b");
4836  if (kcountHEpositivedirectionDigi3 == 7)
4837  HEpositivedirectionDigi3->SetXTitle("R for HE+ jeta = 22; depth = 3 \b");
4838  if (kcountHEpositivedirectionDigi3 == 8)
4839  HEpositivedirectionDigi3->SetXTitle("R for HE+ jeta = 23; depth = 3 \b");
4840  if (kcountHEpositivedirectionDigi3 == 9)
4841  HEpositivedirectionDigi3->SetXTitle("R for HE+ jeta = 24; depth = 3 \b");
4842  if (kcountHEpositivedirectionDigi3 == 10)
4843  HEpositivedirectionDigi3->SetXTitle("R for HE+ jeta = 25; depth = 3 \b");
4844  if (kcountHEpositivedirectionDigi3 == 11)
4845  HEpositivedirectionDigi3->SetXTitle("R for HE+ jeta = 26; depth = 3 \b");
4846  if (kcountHEpositivedirectionDigi3 == 12)
4847  HEpositivedirectionDigi3->SetXTitle("R for HE+ jeta = 27; depth = 3 \b");
4848  if (kcountHEpositivedirectionDigi3 == 13)
4849  HEpositivedirectionDigi3->SetXTitle("R for HE+ jeta = 28; depth = 3 \b");
4850  HEpositivedirectionDigi3->Draw("Error");
4851  kcountHEpositivedirectionDigi3++;
4852  if (kcountHEpositivedirectionDigi3 > 13)
4853  break; // 4x6 = 24
4854  } //ccctest>0
4855 
4856  } // for i
4857  } //if(jeta-41 >= 0)
4858  } //for jeta
4860  c3x5->Update();
4861  c3x5->Print("RdigiPositiveDirectionhistD1PhiSymmetryDepth3HE.png");
4862  c3x5->Clear();
4863  // clean-up
4864  if (h2CeffHEpositivedirectionDigi3)
4865  delete h2CeffHEpositivedirectionDigi3;
4866  //========================================================================================== 7
4867  //======================================================================
4868  //======================================================================1D plot: R vs phi , different eta, depth=4
4869  //cout<<" 1D plot: R vs phi , different eta, depth=4 *****" <<endl;
4870  c3x5->Clear();
4872  c3x5->Divide(3, 5);
4873  c3x5->cd(1);
4874  int kcountHEpositivedirectionDigi4 = 1;
4875  TH1F *h2CeffHEpositivedirectionDigi4 = new TH1F("h2CeffHEpositivedirectionDigi4", "", nphi, 0., 72.);
4876 
4877  for (int jeta = 0; jeta < njeta; jeta++) {
4878  // positivedirectionDigi:
4879  if (jeta - 41 >= 0) {
4880  // for (int i=0;i<ndepth;i++) {
4881  // depth=4
4882  for (int i = 3; i < 4; i++) {
4883  TH1F *HEpositivedirectionDigi4 = (TH1F *)h2CeffHEpositivedirectionDigi4->Clone("twod1");
4884 
4885  float ccctest = 0; // to avoid empty massive elements
4886  for (int jphi = 0; jphi < nphi; jphi++) {
4887  double ccc1 = adigihe[i][jeta][jphi];
4888  if (ccc1 != 0.) {
4889  HEpositivedirectionDigi4->Fill(jphi, ccc1);
4890  ccctest = 1.; //HEpositivedirectionDigi4->SetBinError(i,0.01);
4891  }
4892  } // for jphi
4893  if (ccctest > 0.) {
4894  //cout<<"777 kcountHEpositivedirectionDigi4 = "<<kcountHEpositivedirectionDigi4 <<" jeta-41= "<< jeta-41 <<endl;
4895  c3x5->cd(kcountHEpositivedirectionDigi4);
4896  HEpositivedirectionDigi4->SetMarkerStyle(20);
4897  HEpositivedirectionDigi4->SetMarkerSize(0.4);
4898  HEpositivedirectionDigi4->GetYaxis()->SetLabelSize(0.04);
4899  HEpositivedirectionDigi4->SetXTitle("HEpositivedirectionDigi4 \b");
4900  HEpositivedirectionDigi4->SetMarkerColor(2);
4901  HEpositivedirectionDigi4->SetLineColor(0);
4902  gPad->SetGridy();
4903  gPad->SetGridx();
4904  // gPad->SetLogy();
4905  if (kcountHEpositivedirectionDigi4 == 1)
4906  HEpositivedirectionDigi4->SetXTitle("R for HE+ jeta = 15; depth = 4 \b");
4907  if (kcountHEpositivedirectionDigi4 == 2)
4908  HEpositivedirectionDigi4->SetXTitle("R for HE+ jeta = 17; depth = 4 \b");
4909  if (kcountHEpositivedirectionDigi4 == 3)
4910  HEpositivedirectionDigi4->SetXTitle("R for HE+ jeta = 18; depth = 4 \b");
4911  if (kcountHEpositivedirectionDigi4 == 4)
4912  HEpositivedirectionDigi4->SetXTitle("R for HE+ jeta = 19; depth = 4 \b");
4913  if (kcountHEpositivedirectionDigi4 == 5)
4914  HEpositivedirectionDigi4->SetXTitle("R for HE+ jeta = 20; depth = 4 \b");
4915  if (kcountHEpositivedirectionDigi4 == 6)
4916  HEpositivedirectionDigi4->SetXTitle("R for HE+ jeta = 21; depth = 4 \b");
4917  if (kcountHEpositivedirectionDigi4 == 7)
4918  HEpositivedirectionDigi4->SetXTitle("R for HE+ jeta = 22; depth = 4 \b");
4919  if (kcountHEpositivedirectionDigi4 == 8)
4920  HEpositivedirectionDigi4->SetXTitle("R for HE+ jeta = 23; depth = 4 \b");
4921  if (kcountHEpositivedirectionDigi4 == 9)
4922  HEpositivedirectionDigi4->SetXTitle("R for HE+ jeta = 24; depth = 4 \b");
4923  if (kcountHEpositivedirectionDigi4 == 10)
4924  HEpositivedirectionDigi4->SetXTitle("R for HE+ jeta = 25; depth = 4 \b");
4925  if (kcountHEpositivedirectionDigi4 == 11)
4926  HEpositivedirectionDigi4->SetXTitle("R for HE+ jeta = 26; depth = 4 \b");
4927  if (kcountHEpositivedirectionDigi4 == 12)
4928  HEpositivedirectionDigi4->SetXTitle("R for HE+ jeta = 27; depth = 4 \b");
4929  HEpositivedirectionDigi4->Draw("Error");
4930  kcountHEpositivedirectionDigi4++;
4931  if (kcountHEpositivedirectionDigi4 > 12)
4932  break; // 4x6 = 24
4933  } //ccctest>0
4934 
4935  } // for i
4936  } //if(jeta-41 >= 0)
4937  } //for jeta
4939  c3x5->Update();
4940  c3x5->Print("RdigiPositiveDirectionhistD1PhiSymmetryDepth4HE.png");
4941  c3x5->Clear();
4942  // clean-up
4943  if (h2CeffHEpositivedirectionDigi4)
4944  delete h2CeffHEpositivedirectionDigi4;
4945  //========================================================================================== 8
4946  //======================================================================
4947  //======================================================================1D plot: R vs phi , different eta, depth=5
4948  //cout<<" 1D plot: R vs phi , different eta, depth=5 *****" <<endl;
4949  c3x5->Clear();
4951  c3x5->Divide(3, 5);
4952  c3x5->cd(1);
4953  int kcountHEpositivedirectionDigi5 = 1;
4954  TH1F *h2CeffHEpositivedirectionDigi5 = new TH1F("h2CeffHEpositivedirectionDigi5", "", nphi, 0., 72.);
4955 
4956  for (int jeta = 0; jeta < njeta; jeta++) {
4957  // positivedirectionDigi:
4958  if (jeta - 41 >= 0) {
4959  // for (int i=0;i<ndepth;i++) {
4960  // depth=5
4961  for (int i = 4; i < 5; i++) {
4962  TH1F *HEpositivedirectionDigi5 = (TH1F *)h2CeffHEpositivedirectionDigi5->Clone("twod1");
4963 
4964  float ccctest = 0; // to avoid empty massive elements
4965  for (int jphi = 0; jphi < nphi; jphi++) {
4966  // cout<<"888 initial kcountHEpositivedirectionDigi5 = "<<kcountHEpositivedirectionDigi5 <<" jeta-41= "<< jeta-41 <<" jphi= "<< jphi <<" adigihe[i][jeta][jphi]= "<< adigihe[i][jeta][jphi] <<" depth= "<< i <<endl;
4967 
4968  double ccc1 = adigihe[i][jeta][jphi];
4969  if (ccc1 != 0.) {
4970  HEpositivedirectionDigi5->Fill(jphi, ccc1);
4971  ccctest = 1.; //HEpositivedirectionDigi5->SetBinError(i,0.01);
4972  }
4973  } // for jphi
4974  if (ccctest > 0.) {
4975  //cout<<"888 kcountHEpositivedirectionDigi5 = "<<kcountHEpositivedirectionDigi5 <<" jeta-41= "<< jeta-41 <<endl;
4976  c3x5->cd(kcountHEpositivedirectionDigi5);
4977  HEpositivedirectionDigi5->SetMarkerStyle(20);
4978  HEpositivedirectionDigi5->SetMarkerSize(0.4);
4979  HEpositivedirectionDigi5->GetYaxis()->SetLabelSize(0.04);
4980  HEpositivedirectionDigi5->SetXTitle("HEpositivedirectionDigi5 \b");
4981  HEpositivedirectionDigi5->SetMarkerColor(2);
4982  HEpositivedirectionDigi5->SetLineColor(0);
4983  gPad->SetGridy();
4984  gPad->SetGridx();
4985  // gPad->SetLogy();
4986  if (kcountHEpositivedirectionDigi5 == 1)
4987  HEpositivedirectionDigi5->SetXTitle("R for HE+ jeta = 17; depth = 5 \b");
4988  if (kcountHEpositivedirectionDigi5 == 2)
4989  HEpositivedirectionDigi5->SetXTitle("R for HE+ jeta = 18; depth = 5 \b");
4990  if (kcountHEpositivedirectionDigi5 == 3)
4991  HEpositivedirectionDigi5->SetXTitle("R for HE+ jeta = 19; depth = 5 \b");
4992  if (kcountHEpositivedirectionDigi5 == 4)
4993  HEpositivedirectionDigi5->SetXTitle("R for HE+ jeta = 20; depth = 5 \b");
4994  if (kcountHEpositivedirectionDigi5 == 5)
4995  HEpositivedirectionDigi5->SetXTitle("R for HE+ jeta = 21; depth = 5 \b");
4996  if (kcountHEpositivedirectionDigi5 == 6)
4997  HEpositivedirectionDigi5->SetXTitle("R for HE+ jeta = 22; depth = 5 \b");
4998  if (kcountHEpositivedirectionDigi5 == 7)
4999  HEpositivedirectionDigi5->SetXTitle("R for HE+ jeta = 23; depth = 5 \b");
5000  if (kcountHEpositivedirectionDigi5 == 8)
5001  HEpositivedirectionDigi5->SetXTitle("R for HE+ jeta = 24; depth = 5 \b");
5002  if (kcountHEpositivedirectionDigi5 == 9)
5003  HEpositivedirectionDigi5->SetXTitle("R for HE+ jeta = 25; depth = 5 \b");
5004  if (kcountHEpositivedirectionDigi5 == 10)
5005  HEpositivedirectionDigi5->SetXTitle("R for HE+ jeta = 26; depth = 5 \b");
5006  if (kcountHEpositivedirectionDigi5 == 11)
5007  HEpositivedirectionDigi5->SetXTitle("R for HE+ jeta = 27; depth = 5 \b");
5008  HEpositivedirectionDigi5->Draw("Error");
5009  kcountHEpositivedirectionDigi5++;
5010  if (kcountHEpositivedirectionDigi5 > 11)
5011  break; // 4x6 = 24
5012  } //ccctest>0
5013 
5014  } // for i
5015  } //if(jeta-41 >= 0)
5016  } //for jeta
5018  c3x5->Update();
5019  c3x5->Print("RdigiPositiveDirectionhistD1PhiSymmetryDepth5HE.png");
5020  c3x5->Clear();
5021  // clean-up
5022  if (h2CeffHEpositivedirectionDigi5)
5023  delete h2CeffHEpositivedirectionDigi5;
5024  //========================================================================================== 9
5025  //======================================================================
5026  //======================================================================1D plot: R vs phi , different eta, depth=6
5027  //cout<<" 1D plot: R vs phi , different eta, depth=6 *****" <<endl;
5028  c3x5->Clear();
5030  c3x5->Divide(3, 5);
5031  c3x5->cd(1);
5032  int kcountHEpositivedirectionDigi6 = 1;
5033  TH1F *h2CeffHEpositivedirectionDigi6 = new TH1F("h2CeffHEpositivedirectionDigi6", "", nphi, 0., 72.);
5034 
5035  for (int jeta = 0; jeta < njeta; jeta++) {
5036  // positivedirectionDigi:
5037  if (jeta - 41 >= 0) {
5038  // for (int i=0;i<ndepth;i++) {
5039  // depth=6
5040  for (int i = 5; i < 6; i++) {
5041  TH1F *HEpositivedirectionDigi6 = (TH1F *)h2CeffHEpositivedirectionDigi6->Clone("twod1");
5042 
5043  float ccctest = 0; // to avoid empty massive elements
5044  for (int jphi = 0; jphi < nphi; jphi++) {
5045  double ccc1 = adigihe[i][jeta][jphi];
5046  if (ccc1 != 0.) {
5047  HEpositivedirectionDigi6->Fill(jphi, ccc1);
5048  ccctest = 1.; //HEpositivedirectionDigi6->SetBinError(i,0.01);
5049  }
5050  } // for jphi
5051  if (ccctest > 0.) {
5052  //cout<<"999 kcountHEpositivedirectionDigi6 = "<<kcountHEpositivedirectionDigi6 <<" jeta-41= "<< jeta-41 <<endl;
5053  c3x5->cd(kcountHEpositivedirectionDigi6);
5054  HEpositivedirectionDigi6->SetMarkerStyle(20);
5055  HEpositivedirectionDigi6->SetMarkerSize(0.4);
5056  HEpositivedirectionDigi6->GetYaxis()->SetLabelSize(0.04);
5057  HEpositivedirectionDigi6->SetXTitle("HEpositivedirectionDigi6 \b");
5058  HEpositivedirectionDigi6->SetMarkerColor(2);
5059  HEpositivedirectionDigi6->SetLineColor(0);
5060  gPad->SetGridy();
5061  gPad->SetGridx();
5062  // gPad->SetLogy();
5063  if (kcountHEpositivedirectionDigi6 == 1)
5064  HEpositivedirectionDigi6->SetXTitle("R for HE+ jeta = 18; depth = 6 \b");
5065  if (kcountHEpositivedirectionDigi6 == 2)
5066  HEpositivedirectionDigi6->SetXTitle("R for HE+ jeta = 19; depth = 6 \b");
5067  if (kcountHEpositivedirectionDigi6 == 3)
5068  HEpositivedirectionDigi6->SetXTitle("R for HE+ jeta = 20; depth = 6 \b");
5069  if (kcountHEpositivedirectionDigi6 == 4)
5070  HEpositivedirectionDigi6->SetXTitle("R for HE+ jeta = 21; depth = 6 \b");
5071  if (kcountHEpositivedirectionDigi6 == 5)
5072  HEpositivedirectionDigi6->SetXTitle("R for HE+ jeta = 22; depth = 6 \b");
5073  if (kcountHEpositivedirectionDigi6 == 6)
5074  HEpositivedirectionDigi6->SetXTitle("R for HE+ jeta = 23; depth = 6 \b");
5075  if (kcountHEpositivedirectionDigi6 == 7)
5076  HEpositivedirectionDigi6->SetXTitle("R for HE+ jeta = 24; depth = 6 \b");
5077  if (kcountHEpositivedirectionDigi6 == 8)
5078  HEpositivedirectionDigi6->SetXTitle("R for HE+ jeta = 25; depth = 6 \b");
5079  if (kcountHEpositivedirectionDigi6 == 9)
5080  HEpositivedirectionDigi6->SetXTitle("R for HE+ jeta = 26; depth = 6 \b");
5081  if (kcountHEpositivedirectionDigi6 == 10)
5082  HEpositivedirectionDigi6->SetXTitle("R for HE+ jeta = 27; depth = 6 \b");
5083  HEpositivedirectionDigi6->Draw("Error");
5084  kcountHEpositivedirectionDigi6++;
5085  if (kcountHEpositivedirectionDigi6 > 10)
5086  break; // 4x6 = 24
5087  } //ccctest>0
5088 
5089  } // for i
5090  } //if(jeta-41 >= 0)
5091  } //for jeta
5093  c3x5->Update();
5094  c3x5->Print("RdigiPositiveDirectionhistD1PhiSymmetryDepth6HE.png");
5095  c3x5->Clear();
5096  // clean-up
5097  if (h2CeffHEpositivedirectionDigi6)
5098  delete h2CeffHEpositivedirectionDigi6;
5099  //========================================================================================== 10
5100  //======================================================================
5101  //======================================================================1D plot: R vs phi , different eta, depth=7
5102  //cout<<" 1D plot: R vs phi , different eta, depth=7 *****" <<endl;
5103  c3x5->Clear();
5105  c3x5->Divide(3, 5);
5106  c3x5->cd(1);
5107  int kcountHEpositivedirectionDigi7 = 1;
5108  TH1F *h2CeffHEpositivedirectionDigi7 = new TH1F("h2CeffHEpositivedirectionDigi7", "", nphi, 0., 72.);
5109 
5110  for (int jeta = 0; jeta < njeta; jeta++) {
5111  // positivedirectionDigi:
5112  if (jeta - 41 >= 0) {
5113  // for (int i=0;i<ndepth;i++) {
5114  // depth=7
5115  for (int i = 6; i < 7; i++) {
5116  TH1F *HEpositivedirectionDigi7 = (TH1F *)h2CeffHEpositivedirectionDigi7->Clone("twod1");
5117 
5118  float ccctest = 0; // to avoid empty massive elements
5119  for (int jphi = 0; jphi < nphi; jphi++) {
5120  double ccc1 = adigihe[i][jeta][jphi];
5121  if (ccc1 != 0.) {
5122  HEpositivedirectionDigi7->Fill(jphi, ccc1);
5123  ccctest = 1.; //HEpositivedirectionDigi7->SetBinError(i,0.01);
5124  }
5125  } // for jphi
5126  if (ccctest > 0.) {
5127  //cout<<"1010 kcountHEpositivedirectionDigi7 = "<<kcountHEpositivedirectionDigi7 <<" jeta-41= "<< jeta-41 <<endl;
5128  c3x5->cd(kcountHEpositivedirectionDigi7);
5129  HEpositivedirectionDigi7->SetMarkerStyle(20);
5130  HEpositivedirectionDigi7->SetMarkerSize(0.4);
5131  HEpositivedirectionDigi7->GetYaxis()->SetLabelSize(0.04);
5132  HEpositivedirectionDigi7->SetXTitle("HEpositivedirectionDigi7 \b");
5133  HEpositivedirectionDigi7->SetMarkerColor(2);
5134  HEpositivedirectionDigi7->SetLineColor(0);
5135  gPad->SetGridy();
5136  gPad->SetGridx();
5137  // gPad->SetLogy();
5138  if (kcountHEpositivedirectionDigi7 == 1)
5139  HEpositivedirectionDigi7->SetXTitle("R for HE+ jeta = 25; depth = 7 \b");
5140  if (kcountHEpositivedirectionDigi7 == 2)
5141  HEpositivedirectionDigi7->SetXTitle("R for HE+ jeta = 26; depth = 7 \b");
5142  if (kcountHEpositivedirectionDigi7 == 3)
5143  HEpositivedirectionDigi7->SetXTitle("R for HE+ jeta = 27; depth = 7 \b");
5144  HEpositivedirectionDigi7->Draw("Error");
5145  kcountHEpositivedirectionDigi7++;
5146  if (kcountHEpositivedirectionDigi7 > 3)
5147  break; //
5148  } //ccctest>0
5149 
5150  } // for i
5151  } //if(jeta-41 >= 0)
5152  } //for jeta
5154  c3x5->Update();
5155  c3x5->Print("RdigiPositiveDirectionhistD1PhiSymmetryDepth7HE.png");
5156  c3x5->Clear();
5157  // clean-up
5158  if (h2CeffHEpositivedirectionDigi7)
5159  delete h2CeffHEpositivedirectionDigi7;
5160 
5162  //========================================================================================== 1114
5163  //======================================================================
5164  //======================================================================1D plot: R vs phi , different eta, depth=1
5165  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
5166  c3x5->Clear();
5168  c3x5->Divide(3, 5);
5169  c3x5->cd(1);
5170  int kcountHEnegativedirectionDigi1 = 1;
5171  TH1F *h2CeffHEnegativedirectionDigi1 = new TH1F("h2CeffHEnegativedirectionDigi1", "", nphi, 0., 72.);
5172  for (int jeta = 0; jeta < njeta; jeta++) {
5173  // negativedirectionDigi:
5174  if (jeta - 41 < 0) {
5175  // for (int i=0;i<ndepth;i++) {
5176  // depth=1
5177  for (int i = 0; i < 1; i++) {
5178  TH1F *HEnegativedirectionDigi1 = (TH1F *)h2CeffHEnegativedirectionDigi1->Clone("twod1");
5179  float ccctest = 0; // to avoid empty massive elements
5180  for (int jphi = 0; jphi < nphi; jphi++) {
5181  double ccc1 = adigihe[i][jeta][jphi];
5182  if (ccc1 != 0.) {
5183  HEnegativedirectionDigi1->Fill(jphi, ccc1);
5184  ccctest = 1.; //HEnegativedirectionDigi1->SetBinError(i,0.01);
5185  }
5186  } // for jphi
5187  if (ccctest > 0.) {
5188  // cout<<"444 kcountHEnegativedirectionDigi1 = "<<kcountHEnegativedirectionDigi1 <<" jeta-41= "<< jeta-41 <<endl;
5189  c3x5->cd(kcountHEnegativedirectionDigi1);
5190  HEnegativedirectionDigi1->SetMarkerStyle(20);
5191  HEnegativedirectionDigi1->SetMarkerSize(0.4);
5192  HEnegativedirectionDigi1->GetYaxis()->SetLabelSize(0.04);
5193  HEnegativedirectionDigi1->SetXTitle("HEnegativedirectionDigi1 \b");
5194  HEnegativedirectionDigi1->SetMarkerColor(2);
5195  HEnegativedirectionDigi1->SetLineColor(0);
5196  gPad->SetGridy();
5197  gPad->SetGridx();
5198  // gPad->SetLogy();
5199  if (kcountHEnegativedirectionDigi1 == 1)
5200  HEnegativedirectionDigi1->SetXTitle("R for HE- jeta =-29; depth = 1 \b");
5201  if (kcountHEnegativedirectionDigi1 == 2)
5202  HEnegativedirectionDigi1->SetXTitle("R for HE- jeta =-28; depth = 1 \b");
5203  if (kcountHEnegativedirectionDigi1 == 3)
5204  HEnegativedirectionDigi1->SetXTitle("R for HE- jeta =-27; depth = 1 \b");
5205  if (kcountHEnegativedirectionDigi1 == 4)
5206  HEnegativedirectionDigi1->SetXTitle("R for HE- jeta =-26; depth = 1 \b");
5207  if (kcountHEnegativedirectionDigi1 == 5)
5208  HEnegativedirectionDigi1->SetXTitle("R for HE- jeta =-25; depth = 1 \b");
5209  if (kcountHEnegativedirectionDigi1 == 6)
5210  HEnegativedirectionDigi1->SetXTitle("R for HE- jeta =-24; depth = 1 \b");
5211  if (kcountHEnegativedirectionDigi1 == 7)
5212  HEnegativedirectionDigi1->SetXTitle("R for HE- jeta =-23; depth = 1 \b");
5213  if (kcountHEnegativedirectionDigi1 == 8)
5214  HEnegativedirectionDigi1->SetXTitle("R for HE- jeta =-22; depth = 1 \b");
5215  if (kcountHEnegativedirectionDigi1 == 9)
5216  HEnegativedirectionDigi1->SetXTitle("R for HE- jeta =-21; depth = 1 \b");
5217  if (kcountHEnegativedirectionDigi1 == 10)
5218  HEnegativedirectionDigi1->SetXTitle("R for HE- jeta =-20; depth = 1 \b");
5219  if (kcountHEnegativedirectionDigi1 == 11)
5220  HEnegativedirectionDigi1->SetXTitle("R for HE- jeta =-19; depth = 1 \b");
5221  if (kcountHEnegativedirectionDigi1 == 12)
5222  HEnegativedirectionDigi1->SetXTitle("R for HE- jeta =-18; depth = 1 \b");
5223  HEnegativedirectionDigi1->Draw("Error");
5224  kcountHEnegativedirectionDigi1++;
5225  if (kcountHEnegativedirectionDigi1 > 12)
5226  break; // 4x6 = 24
5227  } //ccctest>0
5228 
5229  } // for i
5230  } //if(jeta-41 < 0)
5231  } //for jeta
5233  c3x5->Update();
5234  c3x5->Print("RdigiNegativeDirectionhistD1PhiSymmetryDepth1HE.png");
5235  c3x5->Clear();
5236  // clean-up
5237  if (h2CeffHEnegativedirectionDigi1)
5238  delete h2CeffHEnegativedirectionDigi1;
5239 
5240  //========================================================================================== 1115
5241  //======================================================================
5242  //======================================================================1D plot: R vs phi , different eta, depth=2
5243  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
5244  c3x5->Clear();
5246  c3x5->Divide(3, 5);
5247  c3x5->cd(1);
5248  int kcountHEnegativedirectionDigi2 = 1;
5249  TH1F *h2CeffHEnegativedirectionDigi2 = new TH1F("h2CeffHEnegativedirectionDigi2", "", nphi, 0., 72.);
5250  for (int jeta = 0; jeta < njeta; jeta++) {
5251  // negativedirectionDigi:
5252  if (jeta - 41 < 0) {
5253  // for (int i=0;i<ndepth;i++) {
5254  // depth=2
5255  for (int i = 1; i < 2; i++) {
5256  TH1F *HEnegativedirectionDigi2 = (TH1F *)h2CeffHEnegativedirectionDigi2->Clone("twod1");
5257  float ccctest = 0; // to avoid empty massive elements
5258  for (int jphi = 0; jphi < nphi; jphi++) {
5259  double ccc1 = adigihe[i][jeta][jphi];
5260  if (ccc1 != 0.) {
5261  HEnegativedirectionDigi2->Fill(jphi, ccc1);
5262  ccctest = 1.; //HEnegativedirectionDigi2->SetBinError(i,0.01);
5263  }
5264  } // for jphi
5265  if (ccctest > 0.) {
5266  //cout<<"555 kcountHEnegativedirectionDigi2 = "<<kcountHEnegativedirectionDigi2 <<" jeta-41= "<< jeta-41 <<endl;
5267  c3x5->cd(kcountHEnegativedirectionDigi2);
5268  HEnegativedirectionDigi2->SetMarkerStyle(20);
5269  HEnegativedirectionDigi2->SetMarkerSize(0.4);
5270  HEnegativedirectionDigi2->GetYaxis()->SetLabelSize(0.04);
5271  HEnegativedirectionDigi2->SetXTitle("HEnegativedirectionDigi2 \b");
5272  HEnegativedirectionDigi2->SetMarkerColor(2);
5273  HEnegativedirectionDigi2->SetLineColor(0);
5274  gPad->SetGridy();
5275  gPad->SetGridx();
5276  // gPad->SetLogy();
5277  if (kcountHEnegativedirectionDigi2 == 1)
5278  HEnegativedirectionDigi2->SetXTitle("R for HE- jeta =-29; depth = 2 \b");
5279  if (kcountHEnegativedirectionDigi2 == 2)
5280  HEnegativedirectionDigi2->SetXTitle("R for HE- jeta =-28; depth = 2 \b");
5281  if (kcountHEnegativedirectionDigi2 == 3)
5282  HEnegativedirectionDigi2->SetXTitle("R for HE- jeta =-27; depth = 2 \b");
5283  if (kcountHEnegativedirectionDigi2 == 4)
5284  HEnegativedirectionDigi2->SetXTitle("R for HE- jeta =-26; depth = 2 \b");
5285  if (kcountHEnegativedirectionDigi2 == 5)
5286  HEnegativedirectionDigi2->SetXTitle("R for HE- jeta =-25; depth = 2 \b");
5287  if (kcountHEnegativedirectionDigi2 == 6)
5288  HEnegativedirectionDigi2->SetXTitle("R for HE- jeta =-24; depth = 2 \b");
5289  if (kcountHEnegativedirectionDigi2 == 7)
5290  HEnegativedirectionDigi2->SetXTitle("R for HE- jeta =-23; depth = 2 \b");
5291  if (kcountHEnegativedirectionDigi2 == 8)
5292  HEnegativedirectionDigi2->SetXTitle("R for HE- jeta =-22; depth = 2 \b");
5293  if (kcountHEnegativedirectionDigi2 == 9)
5294  HEnegativedirectionDigi2->SetXTitle("R for HE- jeta =-21; depth = 2 \b");
5295  if (kcountHEnegativedirectionDigi2 == 10)
5296  HEnegativedirectionDigi2->SetXTitle("R for HE- jeta =-20; depth = 2 \b");
5297  if (kcountHEnegativedirectionDigi2 == 11)
5298  HEnegativedirectionDigi2->SetXTitle("R for HE- jeta =-19; depth = 2 \b");
5299  if (kcountHEnegativedirectionDigi2 == 12)
5300  HEnegativedirectionDigi2->SetXTitle("R for HE- jeta =-18; depth = 2 \b");
5301  if (kcountHEnegativedirectionDigi2 == 13)
5302  HEnegativedirectionDigi2->SetXTitle("R for HE- jeta =-17; depth = 2 \b");
5303  HEnegativedirectionDigi2->Draw("Error");
5304  kcountHEnegativedirectionDigi2++;
5305  if (kcountHEnegativedirectionDigi2 > 13)
5306  break; // 4x6 = 24
5307  } //ccctest>0
5308 
5309  } // for i
5310  } //if(jeta-41 < 0)
5311  } //for jeta
5313  c3x5->Update();
5314  c3x5->Print("RdigiNegativeDirectionhistD1PhiSymmetryDepth2HE.png");
5315  c3x5->Clear();
5316  // clean-up
5317  if (h2CeffHEnegativedirectionDigi2)
5318  delete h2CeffHEnegativedirectionDigi2;
5319  //========================================================================================== 1116
5320  //======================================================================
5321  //======================================================================1D plot: R vs phi , different eta, depth=3
5322  //cout<<" 1D plot: R vs phi , different eta, depth=3 *****" <<endl;
5323  c3x5->Clear();
5325  c3x5->Divide(3, 5);
5326  c3x5->cd(1);
5327  int kcountHEnegativedirectionDigi3 = 1;
5328  TH1F *h2CeffHEnegativedirectionDigi3 = new TH1F("h2CeffHEnegativedirectionDigi3", "", nphi, 0., 72.);
5329  for (int jeta = 0; jeta < njeta; jeta++) {
5330  // negativedirectionDigi:
5331  if (jeta - 41 < 0) {
5332  // for (int i=0;i<ndepth;i++) {
5333  // depth=3
5334  for (int i = 2; i < 3; i++) {
5335  TH1F *HEnegativedirectionDigi3 = (TH1F *)h2CeffHEnegativedirectionDigi3->Clone("twod1");
5336  float ccctest = 0; // to avoid empty massive elements
5337  for (int jphi = 0; jphi < nphi; jphi++) {
5338  double ccc1 = adigihe[i][jeta][jphi];
5339  if (ccc1 != 0.) {
5340  HEnegativedirectionDigi3->Fill(jphi, ccc1);
5341  ccctest = 1.; //HEnegativedirectionDigi3->SetBinError(i,0.01);
5342  }
5343  } // for jphi
5344  if (ccctest > 0.) {
5345  //cout<<"666 kcountHEnegativedirectionDigi3 = "<<kcountHEnegativedirectionDigi3 <<" jeta-41= "<< jeta-41 <<endl;
5346  c3x5->cd(kcountHEnegativedirectionDigi3);
5347  HEnegativedirectionDigi3->SetMarkerStyle(20);
5348  HEnegativedirectionDigi3->SetMarkerSize(0.4);
5349  HEnegativedirectionDigi3->GetYaxis()->SetLabelSize(0.04);
5350  HEnegativedirectionDigi3->SetXTitle("HEnegativedirectionDigi3 \b");
5351  HEnegativedirectionDigi3->SetMarkerColor(2);
5352  HEnegativedirectionDigi3->SetLineColor(0);
5353  gPad->SetGridy();
5354  gPad->SetGridx();
5355  // gPad->SetLogy();
5356  if (kcountHEnegativedirectionDigi3 == 1)
5357  HEnegativedirectionDigi3->SetXTitle("R for HE- jeta =-29; depth = 3 \b");
5358  if (kcountHEnegativedirectionDigi3 == 2)
5359  HEnegativedirectionDigi3->SetXTitle("R for HE- jeta =-28; depth = 3 \b");
5360  if (kcountHEnegativedirectionDigi3 == 3)
5361  HEnegativedirectionDigi3->SetXTitle("R for HE- jeta =-27; depth = 3 \b");
5362  if (kcountHEnegativedirectionDigi3 == 4)
5363  HEnegativedirectionDigi3->SetXTitle("R for HE- jeta =-26; depth = 3 \b");
5364  if (kcountHEnegativedirectionDigi3 == 5)
5365  HEnegativedirectionDigi3->SetXTitle("R for HE- jeta =-25; depth = 3 \b");
5366  if (kcountHEnegativedirectionDigi3 == 6)
5367  HEnegativedirectionDigi3->SetXTitle("R for HE- jeta =-24; depth = 3 \b");
5368  if (kcountHEnegativedirectionDigi3 == 7)
5369  HEnegativedirectionDigi3->SetXTitle("R for HE- jeta =-23; depth = 3 \b");
5370  if (kcountHEnegativedirectionDigi3 == 8)
5371  HEnegativedirectionDigi3->SetXTitle("R for HE- jeta =-22; depth = 3 \b");
5372  if (kcountHEnegativedirectionDigi3 == 9)
5373  HEnegativedirectionDigi3->SetXTitle("R for HE- jeta =-21; depth = 3 \b");
5374  if (kcountHEnegativedirectionDigi3 == 10)
5375  HEnegativedirectionDigi3->SetXTitle("R for HE- jeta =-20; depth = 3 \b");
5376  if (kcountHEnegativedirectionDigi3 == 11)
5377  HEnegativedirectionDigi3->SetXTitle("R for HE- jeta =-19; depth = 3 \b");
5378  if (kcountHEnegativedirectionDigi3 == 12)
5379  HEnegativedirectionDigi3->SetXTitle("R for HE- jeta =-18; depth = 3 \b");
5380  if (kcountHEnegativedirectionDigi3 == 13)
5381  HEnegativedirectionDigi3->SetXTitle("R for HE- jeta =-17; depth = 3 \b");
5382  HEnegativedirectionDigi3->Draw("Error");
5383  kcountHEnegativedirectionDigi3++;
5384  if (kcountHEnegativedirectionDigi3 > 13)
5385  break; // 4x6 = 24
5386  } //ccctest>0
5387 
5388  } // for i
5389  } //if(jeta-41 < 0)
5390  } //for jeta
5392  c3x5->Update();
5393  c3x5->Print("RdigiNegativeDirectionhistD1PhiSymmetryDepth3HE.png");
5394  c3x5->Clear();
5395  // clean-up
5396  if (h2CeffHEnegativedirectionDigi3)
5397  delete h2CeffHEnegativedirectionDigi3;
5398  //========================================================================================== 1117
5399  //======================================================================
5400  //======================================================================1D plot: R vs phi , different eta, depth=4
5401  //cout<<" 1D plot: R vs phi , different eta, depth=4 *****" <<endl;
5402  c3x5->Clear();
5404  c3x5->Divide(3, 5);
5405  c3x5->cd(1);
5406  int kcountHEnegativedirectionDigi4 = 1;
5407  TH1F *h2CeffHEnegativedirectionDigi4 = new TH1F("h2CeffHEnegativedirectionDigi4", "", nphi, 0., 72.);
5408 
5409  for (int jeta = 0; jeta < njeta; jeta++) {
5410  // negativedirectionDigi:
5411  if (jeta - 41 < 0) {
5412  // for (int i=0;i<ndepth;i++) {
5413  // depth=4
5414  for (int i = 3; i < 4; i++) {
5415  TH1F *HEnegativedirectionDigi4 = (TH1F *)h2CeffHEnegativedirectionDigi4->Clone("twod1");
5416 
5417  float ccctest = 0; // to avoid empty massive elements
5418  for (int jphi = 0; jphi < nphi; jphi++) {
5419  double ccc1 = adigihe[i][jeta][jphi];
5420  if (ccc1 != 0.) {
5421  HEnegativedirectionDigi4->Fill(jphi, ccc1);
5422  ccctest = 1.; //HEnegativedirectionDigi4->SetBinError(i,0.01);
5423  }
5424  } // for jphi
5425  if (ccctest > 0.) {
5426  //cout<<"777 kcountHEnegativedirectionDigi4 = "<<kcountHEnegativedirectionDigi4 <<" jeta-41= "<< jeta-41 <<endl;
5427  c3x5->cd(kcountHEnegativedirectionDigi4);
5428  HEnegativedirectionDigi4->SetMarkerStyle(20);
5429  HEnegativedirectionDigi4->SetMarkerSize(0.4);
5430  HEnegativedirectionDigi4->GetYaxis()->SetLabelSize(0.04);
5431  HEnegativedirectionDigi4->SetXTitle("HEnegativedirectionDigi4 \b");
5432  HEnegativedirectionDigi4->SetMarkerColor(2);
5433  HEnegativedirectionDigi4->SetLineColor(0);
5434  gPad->SetGridy();
5435  gPad->SetGridx();
5436  // gPad->SetLogy();
5437  if (kcountHEnegativedirectionDigi4 == 1)
5438  HEnegativedirectionDigi4->SetXTitle("R for HE- jeta =-28; depth = 4 \b");
5439  if (kcountHEnegativedirectionDigi4 == 2)
5440  HEnegativedirectionDigi4->SetXTitle("R for HE- jeta =-27; depth = 4 \b");
5441  if (kcountHEnegativedirectionDigi4 == 3)
5442  HEnegativedirectionDigi4->SetXTitle("R for HE- jeta =-26; depth = 4 \b");
5443  if (kcountHEnegativedirectionDigi4 == 4)
5444  HEnegativedirectionDigi4->SetXTitle("R for HE- jeta =-25; depth = 4 \b");
5445  if (kcountHEnegativedirectionDigi4 == 5)
5446  HEnegativedirectionDigi4->SetXTitle("R for HE- jeta =-24; depth = 4 \b");
5447  if (kcountHEnegativedirectionDigi4 == 6)
5448  HEnegativedirectionDigi4->SetXTitle("R for HE- jeta =-23; depth = 4 \b");
5449  if (kcountHEnegativedirectionDigi4 == 7)
5450  HEnegativedirectionDigi4->SetXTitle("R for HE- jeta =-22; depth = 4 \b");
5451  if (kcountHEnegativedirectionDigi4 == 8)
5452  HEnegativedirectionDigi4->SetXTitle("R for HE- jeta =-21; depth = 4 \b");
5453  if (kcountHEnegativedirectionDigi4 == 9)
5454  HEnegativedirectionDigi4->SetXTitle("R for HE- jeta =-20; depth = 4 \b");
5455  if (kcountHEnegativedirectionDigi4 == 10)
5456  HEnegativedirectionDigi4->SetXTitle("R for HE- jeta =-19; depth = 4 \b");
5457  if (kcountHEnegativedirectionDigi4 == 11)
5458  HEnegativedirectionDigi4->SetXTitle("R for HE- jeta =-18; depth = 4 \b");
5459  if (kcountHEnegativedirectionDigi4 == 12)
5460  HEnegativedirectionDigi4->SetXTitle("R for HE- jeta =-16; depth = 4 \b");
5461  HEnegativedirectionDigi4->Draw("Error");
5462  kcountHEnegativedirectionDigi4++;
5463  if (kcountHEnegativedirectionDigi4 > 12)
5464  break; // 4x6 = 24
5465  } //ccctest>0
5466 
5467  } // for i
5468  } //if(jeta-41 < 0)
5469  } //for jeta
5471  c3x5->Update();
5472  c3x5->Print("RdigiNegativeDirectionhistD1PhiSymmetryDepth4HE.png");
5473  c3x5->Clear();
5474  // clean-up
5475  if (h2CeffHEnegativedirectionDigi4)
5476  delete h2CeffHEnegativedirectionDigi4;
5477  //========================================================================================== 1118
5478  //======================================================================
5479  //======================================================================1D plot: R vs phi , different eta, depth=5
5480  //cout<<" 1D plot: R vs phi , different eta, depth=5 *****" <<endl;
5481  c3x5->Clear();
5483  c3x5->Divide(3, 5);
5484  c3x5->cd(1);
5485  int kcountHEnegativedirectionDigi5 = 1;
5486  TH1F *h2CeffHEnegativedirectionDigi5 = new TH1F("h2CeffHEnegativedirectionDigi5", "", nphi, 0., 72.);
5487 
5488  for (int jeta = 0; jeta < njeta; jeta++) {
5489  // negativedirectionDigi:
5490  if (jeta - 41 < 0) {
5491  // for (int i=0;i<ndepth;i++) {
5492  // depth=5
5493  for (int i = 4; i < 5; i++) {
5494  TH1F *HEnegativedirectionDigi5 = (TH1F *)h2CeffHEnegativedirectionDigi5->Clone("twod1");
5495 
5496  float ccctest = 0; // to avoid empty massive elements
5497  for (int jphi = 0; jphi < nphi; jphi++) {
5498  // cout<<"888 initial kcountHEnegativedirectionDigi5 = "<<kcountHEnegativedirectionDigi5 <<" jeta-41= "<< jeta-41 <<" jphi= "<< jphi <<" adigihe[i][jeta][jphi]= "<< adigihe[i][jeta][jphi] <<" depth= "<< i <<endl;
5499 
5500  double ccc1 = adigihe[i][jeta][jphi];
5501  if (ccc1 != 0.) {
5502  HEnegativedirectionDigi5->Fill(jphi, ccc1);
5503  ccctest = 1.; //HEnegativedirectionDigi5->SetBinError(i,0.01);
5504  }
5505  } // for jphi
5506  if (ccctest > 0.) {
5507  //cout<<"888 kcountHEnegativedirectionDigi5 = "<<kcountHEnegativedirectionDigi5 <<" jeta-41= "<< jeta-41 <<endl;
5508  c3x5->cd(kcountHEnegativedirectionDigi5);
5509  HEnegativedirectionDigi5->SetMarkerStyle(20);
5510  HEnegativedirectionDigi5->SetMarkerSize(0.4);
5511  HEnegativedirectionDigi5->GetYaxis()->SetLabelSize(0.04);
5512  HEnegativedirectionDigi5->SetXTitle("HEnegativedirectionDigi5 \b");
5513  HEnegativedirectionDigi5->SetMarkerColor(2);
5514  HEnegativedirectionDigi5->SetLineColor(0);
5515  gPad->SetGridy();
5516  gPad->SetGridx();
5517  // gPad->SetLogy();
5518  if (kcountHEnegativedirectionDigi5 == 1)
5519  HEnegativedirectionDigi5->SetXTitle("R for HE- jeta =-28; depth = 5 \b");
5520  if (kcountHEnegativedirectionDigi5 == 2)
5521  HEnegativedirectionDigi5->SetXTitle("R for HE- jeta =-27; depth = 5 \b");
5522  if (kcountHEnegativedirectionDigi5 == 3)
5523  HEnegativedirectionDigi5->SetXTitle("R for HE- jeta =-26; depth = 5 \b");
5524  if (kcountHEnegativedirectionDigi5 == 4)
5525  HEnegativedirectionDigi5->SetXTitle("R for HE- jeta =-25; depth = 5 \b");
5526  if (kcountHEnegativedirectionDigi5 == 5)
5527  HEnegativedirectionDigi5->SetXTitle("R for HE- jeta =-24; depth = 5 \b");
5528  if (kcountHEnegativedirectionDigi5 == 6)
5529  HEnegativedirectionDigi5->SetXTitle("R for HE- jeta =-23; depth = 5 \b");
5530  if (kcountHEnegativedirectionDigi5 == 7)
5531  HEnegativedirectionDigi5->SetXTitle("R for HE- jeta =-22; depth = 5 \b");
5532  if (kcountHEnegativedirectionDigi5 == 8)
5533  HEnegativedirectionDigi5->SetXTitle("R for HE- jeta =-21; depth = 5 \b");
5534  if (kcountHEnegativedirectionDigi5 == 9)
5535  HEnegativedirectionDigi5->SetXTitle("R for HE- jeta =-20; depth = 5 \b");
5536  if (kcountHEnegativedirectionDigi5 == 10)
5537  HEnegativedirectionDigi5->SetXTitle("R for HE- jeta =-19; depth = 5 \b");
5538  if (kcountHEnegativedirectionDigi5 == 11)
5539  HEnegativedirectionDigi5->SetXTitle("R for HE- jeta =-18; depth = 5 \b");
5540  HEnegativedirectionDigi5->Draw("Error");
5541  kcountHEnegativedirectionDigi5++;
5542  if (kcountHEnegativedirectionDigi5 > 11)
5543  break; // 4x6 = 24
5544  } //ccctest>0
5545 
5546  } // for i
5547  } //if(jeta-41 < 0)
5548  } //for jeta
5550  c3x5->Update();
5551  c3x5->Print("RdigiNegativeDirectionhistD1PhiSymmetryDepth5HE.png");
5552  c3x5->Clear();
5553  // clean-up
5554  if (h2CeffHEnegativedirectionDigi5)
5555  delete h2CeffHEnegativedirectionDigi5;
5556  //========================================================================================== 1119
5557  //======================================================================
5558  //======================================================================1D plot: R vs phi , different eta, depth=6
5559  //cout<<" 1D plot: R vs phi , different eta, depth=6 *****" <<endl;
5560  c3x5->Clear();
5562  c3x5->Divide(3, 5);
5563  c3x5->cd(1);
5564  int kcountHEnegativedirectionDigi6 = 1;
5565  TH1F *h2CeffHEnegativedirectionDigi6 = new TH1F("h2CeffHEnegativedirectionDigi6", "", nphi, 0., 72.);
5566 
5567  for (int jeta = 0; jeta < njeta; jeta++) {
5568  // negativedirectionDigi:
5569  if (jeta - 41 < 0) {
5570  // for (int i=0;i<ndepth;i++) {
5571  // depth=6
5572  for (int i = 5; i < 6; i++) {
5573  TH1F *HEnegativedirectionDigi6 = (TH1F *)h2CeffHEnegativedirectionDigi6->Clone("twod1");
5574 
5575  float ccctest = 0; // to avoid empty massive elements
5576  for (int jphi = 0; jphi < nphi; jphi++) {
5577  double ccc1 = adigihe[i][jeta][jphi];
5578  if (ccc1 != 0.) {
5579  HEnegativedirectionDigi6->Fill(jphi, ccc1);
5580  ccctest = 1.; //HEnegativedirectionDigi6->SetBinError(i,0.01);
5581  }
5582  } // for jphi
5583  if (ccctest > 0.) {
5584  //cout<<"999 kcountHEnegativedirectionDigi6 = "<<kcountHEnegativedirectionDigi6 <<" jeta-41= "<< jeta-41 <<endl;
5585  c3x5->cd(kcountHEnegativedirectionDigi6);
5586  HEnegativedirectionDigi6->SetMarkerStyle(20);
5587  HEnegativedirectionDigi6->SetMarkerSize(0.4);
5588  HEnegativedirectionDigi6->GetYaxis()->SetLabelSize(0.04);
5589  HEnegativedirectionDigi6->SetXTitle("HEnegativedirectionDigi6 \b");
5590  HEnegativedirectionDigi6->SetMarkerColor(2);
5591  HEnegativedirectionDigi6->SetLineColor(0);
5592  gPad->SetGridy();
5593  gPad->SetGridx();
5594  // gPad->SetLogy();
5595  if (kcountHEnegativedirectionDigi6 == 1)
5596  HEnegativedirectionDigi6->SetXTitle("R for HE- jeta =-28; depth = 6 \b");
5597  if (kcountHEnegativedirectionDigi6 == 2)
5598  HEnegativedirectionDigi6->SetXTitle("R for HE- jeta =-27; depth = 6 \b");
5599  if (kcountHEnegativedirectionDigi6 == 3)
5600  HEnegativedirectionDigi6->SetXTitle("R for HE- jeta =-26; depth = 6 \b");
5601  if (kcountHEnegativedirectionDigi6 == 4)
5602  HEnegativedirectionDigi6->SetXTitle("R for HE- jeta =-25; depth = 6 \b");
5603  if (kcountHEnegativedirectionDigi6 == 5)
5604  HEnegativedirectionDigi6->SetXTitle("R for HE- jeta =-24; depth = 6 \b");
5605  if (kcountHEnegativedirectionDigi6 == 6)
5606  HEnegativedirectionDigi6->SetXTitle("R for HE- jeta =-23; depth = 6 \b");
5607  if (kcountHEnegativedirectionDigi6 == 7)
5608  HEnegativedirectionDigi6->SetXTitle("R for HE- jeta =-22; depth = 6 \b");
5609  if (kcountHEnegativedirectionDigi6 == 8)
5610  HEnegativedirectionDigi6->SetXTitle("R for HE- jeta =-21; depth = 6 \b");
5611  if (kcountHEnegativedirectionDigi6 == 9)
5612  HEnegativedirectionDigi6->SetXTitle("R for HE- jeta =-20; depth = 6 \b");
5613  if (kcountHEnegativedirectionDigi6 == 10)
5614  HEnegativedirectionDigi6->SetXTitle("R for HE- jeta =-19; depth = 6 \b");
5615  HEnegativedirectionDigi6->Draw("Error");
5616  kcountHEnegativedirectionDigi6++;
5617  if (kcountHEnegativedirectionDigi6 > 10)
5618  break; // 4x6 = 24
5619  } //ccctest>0
5620 
5621  } // for i
5622  } //if(jeta-41 < 0)
5623  } //for jeta
5625  c3x5->Update();
5626  c3x5->Print("RdigiNegativeDirectionhistD1PhiSymmetryDepth6HE.png");
5627  c3x5->Clear();
5628  // clean-up
5629  if (h2CeffHEnegativedirectionDigi6)
5630  delete h2CeffHEnegativedirectionDigi6;
5631  //========================================================================================== 11110
5632  //======================================================================
5633  //======================================================================1D plot: R vs phi , different eta, depth=7
5634  //cout<<" 1D plot: R vs phi , different eta, depth=7 *****" <<endl;
5635  c3x5->Clear();
5637  c3x5->Divide(3, 5);
5638  c3x5->cd(1);
5639  int kcountHEnegativedirectionDigi7 = 1;
5640  TH1F *h2CeffHEnegativedirectionDigi7 = new TH1F("h2CeffHEnegativedirectionDigi7", "", nphi, 0., 72.);
5641 
5642  for (int jeta = 0; jeta < njeta; jeta++) {
5643  // negativedirectionDigi:
5644  if (jeta - 41 < 0) {
5645  // for (int i=0;i<ndepth;i++) {
5646  // depth=7
5647  for (int i = 6; i < 7; i++) {
5648  TH1F *HEnegativedirectionDigi7 = (TH1F *)h2CeffHEnegativedirectionDigi7->Clone("twod1");
5649 
5650  float ccctest = 0; // to avoid empty massive elements
5651  for (int jphi = 0; jphi < nphi; jphi++) {
5652  double ccc1 = adigihe[i][jeta][jphi];
5653  if (ccc1 != 0.) {
5654  HEnegativedirectionDigi7->Fill(jphi, ccc1);
5655  ccctest = 1.; //HEnegativedirectionDigi7->SetBinError(i,0.01);
5656  }
5657  } // for jphi
5658  if (ccctest > 0.) {
5659  //cout<<"1010 kcountHEnegativedirectionDigi7 = "<<kcountHEnegativedirectionDigi7 <<" jeta-41= "<< jeta-41 <<endl;
5660  c3x5->cd(kcountHEnegativedirectionDigi7);
5661  HEnegativedirectionDigi7->SetMarkerStyle(20);
5662  HEnegativedirectionDigi7->SetMarkerSize(0.4);
5663  HEnegativedirectionDigi7->GetYaxis()->SetLabelSize(0.04);
5664  HEnegativedirectionDigi7->SetXTitle("HEnegativedirectionDigi7 \b");
5665  HEnegativedirectionDigi7->SetMarkerColor(2);
5666  HEnegativedirectionDigi7->SetLineColor(0);
5667  gPad->SetGridy();
5668  gPad->SetGridx();
5669  // gPad->SetLogy();
5670  if (kcountHEnegativedirectionDigi7 == 1)
5671  HEnegativedirectionDigi7->SetXTitle("R for HE- jeta =-28; depth = 7 \b");
5672  if (kcountHEnegativedirectionDigi7 == 2)
5673  HEnegativedirectionDigi7->SetXTitle("R for HE- jeta =-27; depth = 7 \b");
5674  if (kcountHEnegativedirectionDigi7 == 3)
5675  HEnegativedirectionDigi7->SetXTitle("R for HE- jeta =-26; depth = 7 \b");
5676  HEnegativedirectionDigi7->Draw("Error");
5677  kcountHEnegativedirectionDigi7++;
5678  if (kcountHEnegativedirectionDigi7 > 3)
5679  break; // 4x6 = 24
5680  } //ccctest>0
5681 
5682  } // for i
5683  } //if(jeta-41 < 0)
5684  } //for jeta
5686  c3x5->Update();
5687  c3x5->Print("RdigiNegativeDirectionhistD1PhiSymmetryDepth7HE.png");
5688  c3x5->Clear();
5689  // clean-up
5690  if (h2CeffHEnegativedirectionDigi7)
5691  delete h2CeffHEnegativedirectionDigi7;
5692 
5694 
5695  // DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD:
5696 
5697  //cout<<" Start Vaiance: preparation *****" <<endl;
5698  TH2F *digiVariance1HE1 = (TH2F *)dir->FindObjectAny("h_amplitudechannel2_HE1");
5699  TH2F *digiVariance0HE1 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HE1");
5700  TH2F *digiVarianceHE1 = (TH2F *)digiVariance1HE1->Clone("digiVarianceHE1");
5701  digiVarianceHE1->Divide(digiVariance1HE1, digiVariance0HE1, 1, 1, "B");
5702  TH2F *digiVariance1HE2 = (TH2F *)dir->FindObjectAny("h_amplitudechannel2_HE2");
5703  TH2F *digiVariance0HE2 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HE2");
5704  TH2F *digiVarianceHE2 = (TH2F *)digiVariance1HE2->Clone("digiVarianceHE2");
5705  digiVarianceHE2->Divide(digiVariance1HE2, digiVariance0HE2, 1, 1, "B");
5706  TH2F *digiVariance1HE3 = (TH2F *)dir->FindObjectAny("h_amplitudechannel2_HE3");
5707  TH2F *digiVariance0HE3 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HE3");
5708  TH2F *digiVarianceHE3 = (TH2F *)digiVariance1HE3->Clone("digiVarianceHE3");
5709  digiVarianceHE3->Divide(digiVariance1HE3, digiVariance0HE3, 1, 1, "B");
5710  TH2F *digiVariance1HE4 = (TH2F *)dir->FindObjectAny("h_amplitudechannel2_HE4");
5711  TH2F *digiVariance0HE4 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HE4");
5712  TH2F *digiVarianceHE4 = (TH2F *)digiVariance1HE4->Clone("digiVarianceHE4");
5713  digiVarianceHE4->Divide(digiVariance1HE4, digiVariance0HE4, 1, 1, "B");
5714  TH2F *digiVariance1HE5 = (TH2F *)dir->FindObjectAny("h_amplitudechannel2_HE5");
5715  TH2F *digiVariance0HE5 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HE5");
5716  TH2F *digiVarianceHE5 = (TH2F *)digiVariance1HE5->Clone("digiVarianceHE5");
5717  digiVarianceHE5->Divide(digiVariance1HE5, digiVariance0HE5, 1, 1, "B");
5718  TH2F *digiVariance1HE6 = (TH2F *)dir->FindObjectAny("h_amplitudechannel2_HE6");
5719  TH2F *digiVariance0HE6 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HE6");
5720  TH2F *digiVarianceHE6 = (TH2F *)digiVariance1HE6->Clone("digiVarianceHE6");
5721  digiVarianceHE6->Divide(digiVariance1HE6, digiVariance0HE6, 1, 1, "B");
5722  TH2F *digiVariance1HE7 = (TH2F *)dir->FindObjectAny("h_amplitudechannel2_HE7");
5723  TH2F *digiVariance0HE7 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HE7");
5724  TH2F *digiVarianceHE7 = (TH2F *)digiVariance1HE7->Clone("digiVarianceHE7");
5725  digiVarianceHE7->Divide(digiVariance1HE7, digiVariance0HE7, 1, 1, "B");
5726  //cout<<" Vaiance: preparation DONE *****" <<endl;
5727  //====================================================================== put Vaiance=Dispersia = Sig**2=<R**2> - (<R>)**2 into massive digivariancehe
5728  // = sum(R*R)/N - (sum(R)/N)**2
5729  for (int jeta = 0; jeta < njeta; jeta++) {
5730  //preparation for PHI normalization:
5731  double sumdigiHE0 = 0;
5732  int nsumdigiHE0 = 0;
5733  double sumdigiHE1 = 0;
5734  int nsumdigiHE1 = 0;
5735  double sumdigiHE2 = 0;
5736  int nsumdigiHE2 = 0;
5737  double sumdigiHE3 = 0;
5738  int nsumdigiHE3 = 0;
5739  double sumdigiHE4 = 0;
5740  int nsumdigiHE4 = 0;
5741  double sumdigiHE5 = 0;
5742  int nsumdigiHE5 = 0;
5743  double sumdigiHE6 = 0;
5744  int nsumdigiHE6 = 0;
5745  for (int jphi = 0; jphi < njphi; jphi++) {
5746  digivariancehe[0][jeta][jphi] = digiVarianceHE1->GetBinContent(jeta + 1, jphi + 1);
5747  digivariancehe[1][jeta][jphi] = digiVarianceHE2->GetBinContent(jeta + 1, jphi + 1);
5748  digivariancehe[2][jeta][jphi] = digiVarianceHE3->GetBinContent(jeta + 1, jphi + 1);
5749  digivariancehe[3][jeta][jphi] = digiVarianceHE4->GetBinContent(jeta + 1, jphi + 1);
5750  digivariancehe[4][jeta][jphi] = digiVarianceHE5->GetBinContent(jeta + 1, jphi + 1);
5751  digivariancehe[5][jeta][jphi] = digiVarianceHE6->GetBinContent(jeta + 1, jphi + 1);
5752  digivariancehe[6][jeta][jphi] = digiVarianceHE7->GetBinContent(jeta + 1, jphi + 1);
5753  if (digivariancehe[0][jeta][jphi] > 0.) {
5754  sumdigiHE0 += digivariancehe[0][jeta][jphi];
5755  ++nsumdigiHE0;
5756  }
5757  if (digivariancehe[1][jeta][jphi] > 0.) {
5758  sumdigiHE1 += digivariancehe[1][jeta][jphi];
5759  ++nsumdigiHE1;
5760  }
5761  if (digivariancehe[2][jeta][jphi] > 0.) {
5762  sumdigiHE2 += digivariancehe[2][jeta][jphi];
5763  ++nsumdigiHE2;
5764  }
5765  if (digivariancehe[3][jeta][jphi] > 0.) {
5766  sumdigiHE3 += digivariancehe[3][jeta][jphi];
5767  ++nsumdigiHE3;
5768  }
5769  if (digivariancehe[4][jeta][jphi] > 0.) {
5770  sumdigiHE4 += digivariancehe[4][jeta][jphi];
5771  ++nsumdigiHE4;
5772  }
5773  if (digivariancehe[5][jeta][jphi] > 0.) {
5774  sumdigiHE5 += digivariancehe[5][jeta][jphi];
5775  ++nsumdigiHE5;
5776  }
5777  if (digivariancehe[6][jeta][jphi] > 0.) {
5778  sumdigiHE6 += digivariancehe[6][jeta][jphi];
5779  ++nsumdigiHE6;
5780  }
5781  } // phi
5782  // PHI normalization :
5783  for (int jphi = 0; jphi < njphi; jphi++) {
5784  if (digivariancehe[0][jeta][jphi] > 0.)
5785  digivariancehe[0][jeta][jphi] /= (sumdigiHE0 / nsumdigiHE0);
5786  if (digivariancehe[1][jeta][jphi] > 0.)
5787  digivariancehe[1][jeta][jphi] /= (sumdigiHE1 / nsumdigiHE1);
5788  if (digivariancehe[2][jeta][jphi] > 0.)
5789  digivariancehe[2][jeta][jphi] /= (sumdigiHE2 / nsumdigiHE2);
5790  if (digivariancehe[3][jeta][jphi] > 0.)
5791  digivariancehe[3][jeta][jphi] /= (sumdigiHE3 / nsumdigiHE3);
5792  if (digivariancehe[4][jeta][jphi] > 0.)
5793  digivariancehe[4][jeta][jphi] /= (sumdigiHE4 / nsumdigiHE4);
5794  if (digivariancehe[5][jeta][jphi] > 0.)
5795  digivariancehe[5][jeta][jphi] /= (sumdigiHE5 / nsumdigiHE5);
5796  if (digivariancehe[6][jeta][jphi] > 0.)
5797  digivariancehe[6][jeta][jphi] /= (sumdigiHE6 / nsumdigiHE6);
5798  } // phi
5799  // digivariancehe (D) = sum(R*R)/N - (sum(R)/N)**2
5800  for (int jphi = 0; jphi < njphi; jphi++) {
5801  // cout<<"12 12 12 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
5802  digivariancehe[0][jeta][jphi] -= adigihe[0][jeta][jphi] * adigihe[0][jeta][jphi];
5803  digivariancehe[0][jeta][jphi] = fabs(digivariancehe[0][jeta][jphi]);
5804  digivariancehe[1][jeta][jphi] -= adigihe[1][jeta][jphi] * adigihe[1][jeta][jphi];
5805  digivariancehe[1][jeta][jphi] = fabs(digivariancehe[1][jeta][jphi]);
5806  digivariancehe[2][jeta][jphi] -= adigihe[2][jeta][jphi] * adigihe[2][jeta][jphi];
5807  digivariancehe[2][jeta][jphi] = fabs(digivariancehe[2][jeta][jphi]);
5808  digivariancehe[3][jeta][jphi] -= adigihe[3][jeta][jphi] * adigihe[3][jeta][jphi];
5809  digivariancehe[3][jeta][jphi] = fabs(digivariancehe[3][jeta][jphi]);
5810  digivariancehe[4][jeta][jphi] -= adigihe[4][jeta][jphi] * adigihe[4][jeta][jphi];
5811  digivariancehe[4][jeta][jphi] = fabs(digivariancehe[4][jeta][jphi]);
5812  digivariancehe[5][jeta][jphi] -= adigihe[5][jeta][jphi] * adigihe[5][jeta][jphi];
5813  digivariancehe[5][jeta][jphi] = fabs(digivariancehe[5][jeta][jphi]);
5814  digivariancehe[6][jeta][jphi] -= adigihe[6][jeta][jphi] * adigihe[6][jeta][jphi];
5815  digivariancehe[6][jeta][jphi] = fabs(digivariancehe[6][jeta][jphi]);
5816  }
5817  }
5818  //cout<<" Vaiance: DONE*****" <<endl;
5819  //------------------------ 2D-eta/phi-plot: D, averaged over depthes
5820  //======================================================================
5821  //======================================================================
5822  //cout<<" R2D-eta/phi-plot: D, averaged over depthes *****" <<endl;
5823  c1x1->Clear();
5825  c1x0->Divide(1, 1);
5826  c1x0->cd(1);
5827  TH2F *DefzDdigiHE42D = new TH2F("DefzDdigiHE42D", "", neta, -41., 41., nphi, 0., 72.);
5828  TH2F *DefzDdigiHE42D0 = new TH2F("DefzDdigiHE42D0", "", neta, -41., 41., nphi, 0., 72.);
5829  TH2F *DefzDdigiHE42DF = (TH2F *)DefzDdigiHE42D0->Clone("DefzDdigiHE42DF");
5830  for (int i = 0; i < ndepth; i++) {
5831  for (int jeta = 0; jeta < neta; jeta++) {
5832  for (int jphi = 0; jphi < nphi; jphi++) {
5833  double ccc1 = digivariancehe[i][jeta][jphi];
5834  int k2plot = jeta - 41;
5835  int kkk = k2plot; //if(k2plot >0 kkk=k2plot+1; //-41 +41 !=0
5836  if (adigihe[i][jeta][jphi] > 0.) {
5837  DefzDdigiHE42D->Fill(kkk, jphi, ccc1);
5838  DefzDdigiHE42D0->Fill(kkk, jphi, 1.);
5839  }
5840  }
5841  }
5842  }
5843  DefzDdigiHE42DF->Divide(DefzDdigiHE42D, DefzDdigiHE42D0, 1, 1, "B"); // average A
5844  // DefzDdigiHE1->Sumw2();
5845  gPad->SetGridy();
5846  gPad->SetGridx(); // gPad->SetLogz();
5847  DefzDdigiHE42DF->SetMarkerStyle(20);
5848  DefzDdigiHE42DF->SetMarkerSize(0.4);
5849  DefzDdigiHE42DF->GetZaxis()->SetLabelSize(0.08);
5850  DefzDdigiHE42DF->SetXTitle("<D>_depth #eta \b");
5851  DefzDdigiHE42DF->SetYTitle(" #phi \b");
5852  DefzDdigiHE42DF->SetZTitle("<D>_depth \b");
5853  DefzDdigiHE42DF->SetMarkerColor(2);
5854  DefzDdigiHE42DF->SetLineColor(
5855  0); // DefzDdigiHE42DF->SetMaximum(1.000); // DefzDdigiHE42DF->SetMinimum(1.0);
5856  DefzDdigiHE42DF->Draw("COLZ");
5858  c1x0->Update();
5859  c1x0->Print("DdigiGeneralD2PhiSymmetryHE.png");
5860  c1x0->Clear();
5861  // clean-up
5862  if (DefzDdigiHE42D)
5863  delete DefzDdigiHE42D;
5864  if (DefzDdigiHE42D0)
5865  delete DefzDdigiHE42D0;
5866  if (DefzDdigiHE42DF)
5867  delete DefzDdigiHE42DF;
5868  //====================================================================== 1D plot: D vs phi , averaged over depthes & eta
5869  //======================================================================
5870  //cout<<" 1D plot: D vs phi , averaged over depthes & eta *****" <<endl;
5871  c1x1->Clear();
5873  c1x1->Divide(1, 1);
5874  c1x1->cd(1);
5875  TH1F *DefzDdigiHE41D = new TH1F("DefzDdigiHE41D", "", nphi, 0., 72.);
5876  TH1F *DefzDdigiHE41D0 = new TH1F("DefzDdigiHE41D0", "", nphi, 0., 72.);
5877  TH1F *DefzDdigiHE41DF = (TH1F *)DefzDdigiHE41D0->Clone("DefzDdigiHE41DF");
5878 
5879  for (int jphi = 0; jphi < nphi; jphi++) {
5880  for (int jeta = 0; jeta < neta; jeta++) {
5881  for (int i = 0; i < ndepth; i++) {
5882  double ccc1 = digivariancehe[i][jeta][jphi];
5883  if (adigihe[i][jeta][jphi] > 0.) {
5884  DefzDdigiHE41D->Fill(jphi, ccc1);
5885  DefzDdigiHE41D0->Fill(jphi, 1.);
5886  }
5887  }
5888  }
5889  }
5890  // DefzDdigiHE41D->Sumw2();DefzDdigiHE41D0->Sumw2();
5891 
5892  DefzDdigiHE41DF->Divide(DefzDdigiHE41D, DefzDdigiHE41D0, 1, 1, "B"); // R averaged over depthes & eta
5893  DefzDdigiHE41D0->Sumw2();
5894  // for (int jphi=1;jphi<73;jphi++) {DefzDdigiHE41DF->SetBinError(jphi,0.01);}
5895  gPad->SetGridy();
5896  gPad->SetGridx(); // gPad->SetLogz();
5897  DefzDdigiHE41DF->SetMarkerStyle(20);
5898  DefzDdigiHE41DF->SetMarkerSize(1.4);
5899  DefzDdigiHE41DF->GetZaxis()->SetLabelSize(0.08);
5900  DefzDdigiHE41DF->SetXTitle("#phi \b");
5901  DefzDdigiHE41DF->SetYTitle(" <D> \b");
5902  DefzDdigiHE41DF->SetZTitle("<D>_PHI - AllDepthes \b");
5903  DefzDdigiHE41DF->SetMarkerColor(4);
5904  DefzDdigiHE41DF->SetLineColor(4); // DefzDdigiHE41DF->SetMinimum(0.8); DefzDdigiHE41DF->SetMinimum(-0.015);
5905  DefzDdigiHE41DF->Draw("Error");
5907  c1x1->Update();
5908  c1x1->Print("DdigiGeneralD1PhiSymmetryHE.png");
5909  c1x1->Clear();
5910  // clean-up
5911  if (DefzDdigiHE41D)
5912  delete DefzDdigiHE41D;
5913  if (DefzDdigiHE41D0)
5914  delete DefzDdigiHE41D0;
5915  if (DefzDdigiHE41DF)
5916  delete DefzDdigiHE41DF;
5917  //========================================================================================== 14
5918  //======================================================================
5919  //======================================================================1D plot: D vs phi , different eta, depth=1
5920  //cout<<" 1D plot: D vs phi , different eta, depth=1 *****" <<endl;
5921  c3x5->Clear();
5923  c3x5->Divide(3, 5);
5924  c3x5->cd(1);
5925  int kcountHEpositivedirectionDigiD1 = 1;
5926  TH1F *h2CeffHEpositivedirectionDigiD1 = new TH1F("h2CeffHEpositivedirectionDigiD1", "", nphi, 0., 72.);
5927 
5928  for (int jeta = 0; jeta < njeta; jeta++) {
5929  // positivedirectionDigiD:
5930  if (jeta - 41 >= 0) {
5931  // for (int i=0;i<ndepth;i++) {
5932  // depth=1
5933  for (int i = 0; i < 1; i++) {
5934  TH1F *HEpositivedirectionDigiD1 = (TH1F *)h2CeffHEpositivedirectionDigiD1->Clone("twod1");
5935 
5936  float ccctest = 0; // to avoid empty massive elements
5937  for (int jphi = 0; jphi < nphi; jphi++) {
5938  double ccc1 = digivariancehe[i][jeta][jphi];
5939  if (adigihe[i][jeta][jphi] > 0.) {
5940  HEpositivedirectionDigiD1->Fill(jphi, ccc1);
5941  ccctest = 1.; //HEpositivedirectionDigiD1->SetBinError(i,0.01);
5942  }
5943  } // for jphi
5944  if (ccctest > 0.) {
5945  //cout<<"1414 kcountHEpositivedirectionDigiD1 = "<<kcountHEpositivedirectionDigiD1 <<" jeta-41= "<< jeta-41 <<endl;
5946  c3x5->cd(kcountHEpositivedirectionDigiD1);
5947  HEpositivedirectionDigiD1->SetMarkerStyle(20);
5948  HEpositivedirectionDigiD1->SetMarkerSize(0.4);
5949  HEpositivedirectionDigiD1->GetYaxis()->SetLabelSize(0.04);
5950  HEpositivedirectionDigiD1->SetXTitle("HEpositivedirectionDigiD1 \b");
5951  HEpositivedirectionDigiD1->SetMarkerColor(2);
5952  HEpositivedirectionDigiD1->SetLineColor(0);
5953  gPad->SetGridy();
5954  gPad->SetGridx();
5955  // gPad->SetLogy();
5956  if (kcountHEpositivedirectionDigiD1 == 1)
5957  HEpositivedirectionDigiD1->SetXTitle("D for HE+ jeta = 17; depth = 1 \b");
5958  if (kcountHEpositivedirectionDigiD1 == 2)
5959  HEpositivedirectionDigiD1->SetXTitle("D for HE+ jeta = 18; depth = 1 \b");
5960  if (kcountHEpositivedirectionDigiD1 == 3)
5961  HEpositivedirectionDigiD1->SetXTitle("D for HE+ jeta = 19; depth = 1 \b");
5962  if (kcountHEpositivedirectionDigiD1 == 4)
5963  HEpositivedirectionDigiD1->SetXTitle("D for HE+ jeta = 20; depth = 1 \b");
5964  if (kcountHEpositivedirectionDigiD1 == 5)
5965  HEpositivedirectionDigiD1->SetXTitle("D for HE+ jeta = 21; depth = 1 \b");
5966  if (kcountHEpositivedirectionDigiD1 == 6)
5967  HEpositivedirectionDigiD1->SetXTitle("D for HE+ jeta = 22; depth = 1 \b");
5968  if (kcountHEpositivedirectionDigiD1 == 7)
5969  HEpositivedirectionDigiD1->SetXTitle("D for HE+ jeta = 23; depth = 1 \b");
5970  if (kcountHEpositivedirectionDigiD1 == 8)
5971  HEpositivedirectionDigiD1->SetXTitle("D for HE+ jeta = 24; depth = 1 \b");
5972  if (kcountHEpositivedirectionDigiD1 == 9)
5973  HEpositivedirectionDigiD1->SetXTitle("D for HE+ jeta = 25; depth = 1 \b");
5974  if (kcountHEpositivedirectionDigiD1 == 10)
5975  HEpositivedirectionDigiD1->SetXTitle("D for HE+ jeta = 26; depth = 1 \b");
5976  if (kcountHEpositivedirectionDigiD1 == 11)
5977  HEpositivedirectionDigiD1->SetXTitle("D for HE+ jeta = 27; depth = 1 \b");
5978  if (kcountHEpositivedirectionDigiD1 == 12)
5979  HEpositivedirectionDigiD1->SetXTitle("D for HE+ jeta = 28; depth = 1 \b");
5980  HEpositivedirectionDigiD1->Draw("Error");
5981  kcountHEpositivedirectionDigiD1++;
5982  if (kcountHEpositivedirectionDigiD1 > 12)
5983  break; // 4x6 = 24
5984  } //ccctest>0
5985 
5986  } // for i
5987  } //if(jeta-41 >= 0)
5988  } //for jeta
5990  c3x5->Update();
5991  c3x5->Print("DdigiPositiveDirectionhistD1PhiSymmetryDepth1HE.png");
5992  c3x5->Clear();
5993  // clean-up
5994  if (h2CeffHEpositivedirectionDigiD1)
5995  delete h2CeffHEpositivedirectionDigiD1;
5996  //========================================================================================== 15
5997  //======================================================================
5998  //======================================================================1D plot: D vs phi , different eta, depth=2
5999  //cout<<" 1D plot: D vs phi , different eta, depth=2 *****" <<endl;
6000  c3x5->Clear();
6001  c3x5->Divide(3, 5);
6002  c3x5->cd(1);
6003  int kcountHEpositivedirectionDigiD2 = 1;
6004  TH1F *h2CeffHEpositivedirectionDigiD2 = new TH1F("h2CeffHEpositivedirectionDigiD2", "", nphi, 0., 72.);
6005 
6006  for (int jeta = 0; jeta < njeta; jeta++) {
6007  // positivedirectionDigiD:
6008  if (jeta - 41 >= 0) {
6009  // for (int i=0;i<ndepth;i++) {
6010  // depth=2
6011  for (int i = 1; i < 2; i++) {
6012  TH1F *HEpositivedirectionDigiD2 = (TH1F *)h2CeffHEpositivedirectionDigiD2->Clone("twod1");
6013 
6014  float ccctest = 0; // to avoid empty massive elements
6015  for (int jphi = 0; jphi < nphi; jphi++) {
6016  double ccc1 = digivariancehe[i][jeta][jphi];
6017  if (adigihe[i][jeta][jphi] > 0.) {
6018  HEpositivedirectionDigiD2->Fill(jphi, ccc1);
6019  ccctest = 1.; //HEpositivedirectionDigiD2->SetBinError(i,0.01);
6020  }
6021  } // for jphi
6022  if (ccctest > 0.) {
6023  //cout<<"1515 kcountHEpositivedirectionDigiD2 = "<<kcountHEpositivedirectionDigiD2 <<" jeta-41= "<< jeta-41 <<endl;
6024  c3x5->cd(kcountHEpositivedirectionDigiD2);
6025  HEpositivedirectionDigiD2->SetMarkerStyle(20);
6026  HEpositivedirectionDigiD2->SetMarkerSize(0.4);
6027  HEpositivedirectionDigiD2->GetYaxis()->SetLabelSize(0.04);
6028  HEpositivedirectionDigiD2->SetXTitle("HEpositivedirectionDigiD2 \b");
6029  HEpositivedirectionDigiD2->SetMarkerColor(2);
6030  HEpositivedirectionDigiD2->SetLineColor(0);
6031  gPad->SetGridy();
6032  gPad->SetGridx();
6033  // gPad->SetLogy();
6034  if (kcountHEpositivedirectionDigiD2 == 1)
6035  HEpositivedirectionDigiD2->SetXTitle("D for HE+ jeta = 16; depth = 2 \b");
6036  if (kcountHEpositivedirectionDigiD2 == 2)
6037  HEpositivedirectionDigiD2->SetXTitle("D for HE+ jeta = 17; depth = 2 \b");
6038  if (kcountHEpositivedirectionDigiD2 == 3)
6039  HEpositivedirectionDigiD2->SetXTitle("D for HE+ jeta = 18; depth = 2 \b");
6040  if (kcountHEpositivedirectionDigiD2 == 4)
6041  HEpositivedirectionDigiD2->SetXTitle("D for HE+ jeta = 19; depth = 2 \b");
6042  if (kcountHEpositivedirectionDigiD2 == 5)
6043  HEpositivedirectionDigiD2->SetXTitle("D for HE+ jeta = 20; depth = 2 \b");
6044  if (kcountHEpositivedirectionDigiD2 == 6)
6045  HEpositivedirectionDigiD2->SetXTitle("D for HE+ jeta = 21; depth = 2 \b");
6046  if (kcountHEpositivedirectionDigiD2 == 7)
6047  HEpositivedirectionDigiD2->SetXTitle("D for HE+ jeta = 22; depth = 2 \b");
6048  if (kcountHEpositivedirectionDigiD2 == 8)
6049  HEpositivedirectionDigiD2->SetXTitle("D for HE+ jeta = 23; depth = 2 \b");
6050  if (kcountHEpositivedirectionDigiD2 == 9)
6051  HEpositivedirectionDigiD2->SetXTitle("D for HE+ jeta = 24; depth = 2 \b");
6052  if (kcountHEpositivedirectionDigiD2 == 10)
6053  HEpositivedirectionDigiD2->SetXTitle("D for HE+ jeta = 25; depth = 2 \b");
6054  if (kcountHEpositivedirectionDigiD2 == 11)
6055  HEpositivedirectionDigiD2->SetXTitle("D for HE+ jeta = 26; depth = 2 \b");
6056  if (kcountHEpositivedirectionDigiD2 == 12)
6057  HEpositivedirectionDigiD2->SetXTitle("D for HE+ jeta = 27; depth = 2 \b");
6058  if (kcountHEpositivedirectionDigiD2 == 13)
6059  HEpositivedirectionDigiD2->SetXTitle("D for HE+ jeta = 28; depth = 2 \b");
6060  HEpositivedirectionDigiD2->Draw("Error");
6061  kcountHEpositivedirectionDigiD2++;
6062  if (kcountHEpositivedirectionDigiD2 > 13)
6063  break; // 4x6 = 24
6064  } //ccctest>0
6065 
6066  } // for i
6067  } //if(jeta-41 >= 0)
6068  } //for jeta
6070  c3x5->Update();
6071  c3x5->Print("DdigiPositiveDirectionhistD1PhiSymmetryDepth2HE.png");
6072  c3x5->Clear();
6073  // clean-up
6074  if (h2CeffHEpositivedirectionDigiD2)
6075  delete h2CeffHEpositivedirectionDigiD2;
6076  //========================================================================================== 16
6077  //======================================================================
6078  //======================================================================1D plot: D vs phi , different eta, depth=3
6079  //cout<<" 1D plot: D vs phi , different eta, depth=3 *****" <<endl;
6080  c3x5->Clear();
6081  c3x5->Divide(3, 5);
6082  c3x5->cd(1);
6083  int kcountHEpositivedirectionDigiD3 = 1;
6084  TH1F *h2CeffHEpositivedirectionDigiD3 = new TH1F("h2CeffHEpositivedirectionDigiD3", "", nphi, 0., 72.);
6085 
6086  for (int jeta = 0; jeta < njeta; jeta++) {
6087  // positivedirectionDigiD:
6088  if (jeta - 41 >= 0) {
6089  // for (int i=0;i<ndepth;i++) {
6090  // depth=3
6091  for (int i = 2; i < 3; i++) {
6092  TH1F *HEpositivedirectionDigiD3 = (TH1F *)h2CeffHEpositivedirectionDigiD3->Clone("twod1");
6093 
6094  float ccctest = 0; // to avoid empty massive elements
6095  for (int jphi = 0; jphi < nphi; jphi++) {
6096  double ccc1 = digivariancehe[i][jeta][jphi];
6097  if (adigihe[i][jeta][jphi] > 0.) {
6098  HEpositivedirectionDigiD3->Fill(jphi, ccc1);
6099  ccctest = 1.; //HEpositivedirectionDigiD3->SetBinError(i,0.01);
6100  }
6101  } // for jphi
6102  if (ccctest > 0.) {
6103  //cout<<"1616 kcountHEpositivedirectionDigiD3 = "<<kcountHEpositivedirectionDigiD3 <<" jeta-41= "<< jeta-41 <<endl;
6104  c3x5->cd(kcountHEpositivedirectionDigiD3);
6105  HEpositivedirectionDigiD3->SetMarkerStyle(20);
6106  HEpositivedirectionDigiD3->SetMarkerSize(0.4);
6107  HEpositivedirectionDigiD3->GetYaxis()->SetLabelSize(0.04);
6108  HEpositivedirectionDigiD3->SetXTitle("HEpositivedirectionDigiD3 \b");
6109  HEpositivedirectionDigiD3->SetMarkerColor(2);
6110  HEpositivedirectionDigiD3->SetLineColor(0);
6111  gPad->SetGridy();
6112  gPad->SetGridx();
6113  // gPad->SetLogy();
6114  if (kcountHEpositivedirectionDigiD3 == 1)
6115  HEpositivedirectionDigiD3->SetXTitle("D for HE+ jeta = 16; depth = 3 \b");
6116  if (kcountHEpositivedirectionDigiD3 == 2)
6117  HEpositivedirectionDigiD3->SetXTitle("D for HE+ jeta = 17; depth = 3 \b");
6118  if (kcountHEpositivedirectionDigiD3 == 3)
6119  HEpositivedirectionDigiD3->SetXTitle("D for HE+ jeta = 18; depth = 3 \b");
6120  if (kcountHEpositivedirectionDigiD3 == 4)
6121  HEpositivedirectionDigiD3->SetXTitle("D for HE+ jeta = 19; depth = 3 \b");
6122  if (kcountHEpositivedirectionDigiD3 == 5)
6123  HEpositivedirectionDigiD3->SetXTitle("D for HE+ jeta = 20; depth = 3 \b");
6124  if (kcountHEpositivedirectionDigiD3 == 6)
6125  HEpositivedirectionDigiD3->SetXTitle("D for HE+ jeta = 21; depth = 3 \b");
6126  if (kcountHEpositivedirectionDigiD3 == 7)
6127  HEpositivedirectionDigiD3->SetXTitle("D for HE+ jeta = 22; depth = 3 \b");
6128  if (kcountHEpositivedirectionDigiD3 == 8)
6129  HEpositivedirectionDigiD3->SetXTitle("D for HE+ jeta = 23; depth = 3 \b");
6130  if (kcountHEpositivedirectionDigiD3 == 9)
6131  HEpositivedirectionDigiD3->SetXTitle("D for HE+ jeta = 24; depth = 3 \b");
6132  if (kcountHEpositivedirectionDigiD3 == 10)
6133  HEpositivedirectionDigiD3->SetXTitle("D for HE+ jeta = 25; depth = 3 \b");
6134  if (kcountHEpositivedirectionDigiD3 == 11)
6135  HEpositivedirectionDigiD3->SetXTitle("D for HE+ jeta = 26; depth = 3 \b");
6136  if (kcountHEpositivedirectionDigiD3 == 12)
6137  HEpositivedirectionDigiD3->SetXTitle("D for HE+ jeta = 27; depth = 3 \b");
6138  if (kcountHEpositivedirectionDigiD3 == 13)
6139  HEpositivedirectionDigiD3->SetXTitle("D for HE+ jeta = 28; depth = 3 \b");
6140  HEpositivedirectionDigiD3->Draw("Error");
6141  kcountHEpositivedirectionDigiD3++;
6142  if (kcountHEpositivedirectionDigiD3 > 13)
6143  break; // 4x6 = 24
6144  } //ccctest>0
6145 
6146  } // for i
6147  } //if(jeta-41 >= 0)
6148  } //for jeta
6150  c3x5->Update();
6151  c3x5->Print("DdigiPositiveDirectionhistD1PhiSymmetryDepth3HE.png");
6152  c3x5->Clear();
6153  // clean-up
6154  if (h2CeffHEpositivedirectionDigiD3)
6155  delete h2CeffHEpositivedirectionDigiD3;
6156  //========================================================================================== 17
6157  //======================================================================
6158  //======================================================================1D plot: D vs phi , different eta, depth=4
6159  //cout<<" 1D plot: D vs phi , different eta, depth=4 *****" <<endl;
6160  c3x5->Clear();
6161  c3x5->Divide(3, 5);
6162  c3x5->cd(1);
6163  int kcountHEpositivedirectionDigiD4 = 1;
6164  TH1F *h2CeffHEpositivedirectionDigiD4 = new TH1F("h2CeffHEpositivedirectionDigiD4", "", nphi, 0., 72.);
6165 
6166  for (int jeta = 0; jeta < njeta; jeta++) {
6167  // positivedirectionDigiD:
6168  if (jeta - 41 >= 0) {
6169  // for (int i=0;i<ndepth;i++) {
6170  // depth=4
6171  for (int i = 3; i < 4; i++) {
6172  TH1F *HEpositivedirectionDigiD4 = (TH1F *)h2CeffHEpositivedirectionDigiD4->Clone("twod1");
6173 
6174  float ccctest = 0; // to avoid empty massive elements
6175  for (int jphi = 0; jphi < nphi; jphi++) {
6176  double ccc1 = digivariancehe[i][jeta][jphi];
6177  if (adigihe[i][jeta][jphi] > 0.) {
6178  HEpositivedirectionDigiD4->Fill(jphi, ccc1);
6179  ccctest = 1.; //HEpositivedirectionDigiD4->SetBinError(i,0.01);
6180  }
6181  } // for jphi
6182  if (ccctest > 0.) {
6183  //cout<<"1717 kcountHEpositivedirectionDigiD4 = "<<kcountHEpositivedirectionDigiD4 <<" jeta-41= "<< jeta-41 <<endl;
6184  c3x5->cd(kcountHEpositivedirectionDigiD4);
6185  HEpositivedirectionDigiD4->SetMarkerStyle(20);
6186  HEpositivedirectionDigiD4->SetMarkerSize(0.4);
6187  HEpositivedirectionDigiD4->GetYaxis()->SetLabelSize(0.04);
6188  HEpositivedirectionDigiD4->SetXTitle("HEpositivedirectionDigiD4 \b");
6189  HEpositivedirectionDigiD4->SetMarkerColor(2);
6190  HEpositivedirectionDigiD4->SetLineColor(0);
6191  gPad->SetGridy();
6192  gPad->SetGridx();
6193  // gPad->SetLogy();
6194  if (kcountHEpositivedirectionDigiD4 == 1)
6195  HEpositivedirectionDigiD4->SetXTitle("D for HE+ jeta = 15; depth = 4 \b");
6196  if (kcountHEpositivedirectionDigiD4 == 2)
6197  HEpositivedirectionDigiD4->SetXTitle("D for HE+ jeta = 17; depth = 4 \b");
6198  if (kcountHEpositivedirectionDigiD4 == 3)
6199  HEpositivedirectionDigiD4->SetXTitle("D for HE+ jeta = 18; depth = 4 \b");
6200  if (kcountHEpositivedirectionDigiD4 == 4)
6201  HEpositivedirectionDigiD4->SetXTitle("D for HE+ jeta = 19; depth = 4 \b");
6202  if (kcountHEpositivedirectionDigiD4 == 5)
6203  HEpositivedirectionDigiD4->SetXTitle("D for HE+ jeta = 20; depth = 4 \b");
6204  if (kcountHEpositivedirectionDigiD4 == 6)
6205  HEpositivedirectionDigiD4->SetXTitle("D for HE+ jeta = 21; depth = 4 \b");
6206  if (kcountHEpositivedirectionDigiD4 == 7)
6207  HEpositivedirectionDigiD4->SetXTitle("D for HE+ jeta = 22; depth = 4 \b");
6208  if (kcountHEpositivedirectionDigiD4 == 8)
6209  HEpositivedirectionDigiD4->SetXTitle("D for HE+ jeta = 23; depth = 4 \b");
6210  if (kcountHEpositivedirectionDigiD4 == 9)
6211  HEpositivedirectionDigiD4->SetXTitle("D for HE+ jeta = 24; depth = 4 \b");
6212  if (kcountHEpositivedirectionDigiD4 == 10)
6213  HEpositivedirectionDigiD4->SetXTitle("D for HE+ jeta = 25; depth = 4 \b");
6214  if (kcountHEpositivedirectionDigiD4 == 11)
6215  HEpositivedirectionDigiD4->SetXTitle("D for HE+ jeta = 26; depth = 4 \b");
6216  if (kcountHEpositivedirectionDigiD4 == 12)
6217  HEpositivedirectionDigiD4->SetXTitle("D for HE+ jeta = 27; depth = 4 \b");
6218  HEpositivedirectionDigiD4->Draw("Error");
6219  kcountHEpositivedirectionDigiD4++;
6220  if (kcountHEpositivedirectionDigiD4 > 12)
6221  break; // 4x6 = 24
6222  } //ccctest>0
6223 
6224  } // for i
6225  } //if(jeta-41 >= 0)
6226  } //for jeta
6228  c3x5->Update();
6229  c3x5->Print("DdigiPositiveDirectionhistD1PhiSymmetryDepth4HE.png");
6230  c3x5->Clear();
6231  // clean-up
6232  if (h2CeffHEpositivedirectionDigiD4)
6233  delete h2CeffHEpositivedirectionDigiD4;
6234  //========================================================================================== 18
6235  //======================================================================
6236  //======================================================================1D plot: D vs phi , different eta, depth=5
6237  //cout<<" 1D plot: D vs phi , different eta, depth=5 *****" <<endl;
6238  c3x5->Clear();
6239  c3x5->Divide(3, 5);
6240  c3x5->cd(1);
6241  int kcountHEpositivedirectionDigiD5 = 1;
6242  TH1F *h2CeffHEpositivedirectionDigiD5 = new TH1F("h2CeffHEpositivedirectionDigiD5", "", nphi, 0., 72.);
6243 
6244  for (int jeta = 0; jeta < njeta; jeta++) {
6245  // positivedirectionDigiD:
6246  if (jeta - 41 >= 0) {
6247  // for (int i=0;i<ndepth;i++) {
6248  // depth=5
6249  for (int i = 4; i < 5; i++) {
6250  TH1F *HEpositivedirectionDigiD5 = (TH1F *)h2CeffHEpositivedirectionDigiD5->Clone("twod1");
6251 
6252  float ccctest = 0; // to avoid empty massive elements
6253  for (int jphi = 0; jphi < nphi; jphi++) {
6254  double ccc1 = digivariancehe[i][jeta][jphi];
6255  if (adigihe[i][jeta][jphi] > 0.) {
6256  HEpositivedirectionDigiD5->Fill(jphi, ccc1);
6257  ccctest = 1.; //HEpositivedirectionDigiD5->SetBinError(i,0.01);
6258  }
6259  } // for jphi
6260  if (ccctest > 0.) {
6261  //cout<<"1818 kcountHEpositivedirectionDigiD5 = "<<kcountHEpositivedirectionDigiD5 <<" jeta-41= "<< jeta-41 <<endl;
6262  c3x5->cd(kcountHEpositivedirectionDigiD5);
6263  HEpositivedirectionDigiD5->SetMarkerStyle(20);
6264  HEpositivedirectionDigiD5->SetMarkerSize(0.4);
6265  HEpositivedirectionDigiD5->GetYaxis()->SetLabelSize(0.04);
6266  HEpositivedirectionDigiD5->SetXTitle("HEpositivedirectionDigiD5 \b");
6267  HEpositivedirectionDigiD5->SetMarkerColor(2);
6268  HEpositivedirectionDigiD5->SetLineColor(0);
6269  gPad->SetGridy();
6270  gPad->SetGridx();
6271  // gPad->SetLogy();
6272  if (kcountHEpositivedirectionDigiD5 == 1)
6273  HEpositivedirectionDigiD5->SetXTitle("D for HE+ jeta = 17; depth = 5 \b");
6274  if (kcountHEpositivedirectionDigiD5 == 2)
6275  HEpositivedirectionDigiD5->SetXTitle("D for HE+ jeta = 18; depth = 5 \b");
6276  if (kcountHEpositivedirectionDigiD5 == 3)
6277  HEpositivedirectionDigiD5->SetXTitle("D for HE+ jeta = 19; depth = 5 \b");
6278  if (kcountHEpositivedirectionDigiD5 == 4)
6279  HEpositivedirectionDigiD5->SetXTitle("D for HE+ jeta = 20; depth = 5 \b");
6280  if (kcountHEpositivedirectionDigiD5 == 5)
6281  HEpositivedirectionDigiD5->SetXTitle("D for HE+ jeta = 21; depth = 5 \b");
6282  if (kcountHEpositivedirectionDigiD5 == 6)
6283  HEpositivedirectionDigiD5->SetXTitle("D for HE+ jeta = 22; depth = 5 \b");
6284  if (kcountHEpositivedirectionDigiD5 == 7)
6285  HEpositivedirectionDigiD5->SetXTitle("D for HE+ jeta = 23; depth = 5 \b");
6286  if (kcountHEpositivedirectionDigiD5 == 8)
6287  HEpositivedirectionDigiD5->SetXTitle("D for HE+ jeta = 24; depth = 5 \b");
6288  if (kcountHEpositivedirectionDigiD5 == 9)
6289  HEpositivedirectionDigiD5->SetXTitle("D for HE+ jeta = 25; depth = 5 \b");
6290  if (kcountHEpositivedirectionDigiD5 == 10)
6291  HEpositivedirectionDigiD5->SetXTitle("D for HE+ jeta = 26; depth = 5 \b");
6292  if (kcountHEpositivedirectionDigiD5 == 11)
6293  HEpositivedirectionDigiD5->SetXTitle("D for HE+ jeta = 27; depth = 5 \b");
6294  HEpositivedirectionDigiD5->Draw("Error");
6295  kcountHEpositivedirectionDigiD5++;
6296  if (kcountHEpositivedirectionDigiD5 > 11)
6297  break; // 4x6 = 24
6298  } //ccctest>0
6299 
6300  } // for i
6301  } //if(jeta-41 >= 0)
6302  } //for jeta
6304  c3x5->Update();
6305  c3x5->Print("DdigiPositiveDirectionhistD1PhiSymmetryDepth5HE.png");
6306  c3x5->Clear();
6307  // clean-up
6308  if (h2CeffHEpositivedirectionDigiD5)
6309  delete h2CeffHEpositivedirectionDigiD5;
6310  //========================================================================================== 19
6311  //======================================================================
6312  //======================================================================1D plot: D vs phi , different eta, depth=6
6313  //cout<<" 1D plot: D vs phi , different eta, depth=6 *****" <<endl;
6314  c3x5->Clear();
6315  c3x5->Divide(3, 5);
6316  c3x5->cd(1);
6317  int kcountHEpositivedirectionDigiD6 = 1;
6318  TH1F *h2CeffHEpositivedirectionDigiD6 = new TH1F("h2CeffHEpositivedirectionDigiD6", "", nphi, 0., 72.);
6319 
6320  for (int jeta = 0; jeta < njeta; jeta++) {
6321  // positivedirectionDigiD:
6322  if (jeta - 41 >= 0) {
6323  // for (int i=0;i<ndepth;i++) {
6324  // depth=6
6325  for (int i = 5; i < 6; i++) {
6326  TH1F *HEpositivedirectionDigiD6 = (TH1F *)h2CeffHEpositivedirectionDigiD6->Clone("twod1");
6327 
6328  float ccctest = 0; // to avoid empty massive elements
6329  for (int jphi = 0; jphi < nphi; jphi++) {
6330  double ccc1 = digivariancehe[i][jeta][jphi];
6331  if (adigihe[i][jeta][jphi] > 0.) {
6332  HEpositivedirectionDigiD6->Fill(jphi, ccc1);
6333  ccctest = 1.; //HEpositivedirectionDigiD6->SetBinError(i,0.01);
6334  }
6335  } // for jphi
6336  if (ccctest > 0.) {
6337  //cout<<"1919 kcountHEpositivedirectionDigiD6 = "<<kcountHEpositivedirectionDigiD6 <<" jeta-41= "<< jeta-41 <<endl;
6338  c3x5->cd(kcountHEpositivedirectionDigiD6);
6339  HEpositivedirectionDigiD6->SetMarkerStyle(20);
6340  HEpositivedirectionDigiD6->SetMarkerSize(0.4);
6341  HEpositivedirectionDigiD6->GetYaxis()->SetLabelSize(0.04);
6342  HEpositivedirectionDigiD6->SetXTitle("HEpositivedirectionDigiD6 \b");
6343  HEpositivedirectionDigiD6->SetMarkerColor(2);
6344  HEpositivedirectionDigiD6->SetLineColor(0);
6345  gPad->SetGridy();
6346  gPad->SetGridx();
6347  // gPad->SetLogy();
6348  if (kcountHEpositivedirectionDigiD6 == 1)
6349  HEpositivedirectionDigiD6->SetXTitle("D for HE+ jeta = 18; depth = 6 \b");
6350  if (kcountHEpositivedirectionDigiD6 == 2)
6351  HEpositivedirectionDigiD6->SetXTitle("D for HE+ jeta = 19; depth = 6 \b");
6352  if (kcountHEpositivedirectionDigiD6 == 3)
6353  HEpositivedirectionDigiD6->SetXTitle("D for HE+ jeta = 20; depth = 6 \b");
6354  if (kcountHEpositivedirectionDigiD6 == 4)
6355  HEpositivedirectionDigiD6->SetXTitle("D for HE+ jeta = 21; depth = 6 \b");
6356  if (kcountHEpositivedirectionDigiD6 == 5)
6357  HEpositivedirectionDigiD6->SetXTitle("D for HE+ jeta = 22; depth = 6 \b");
6358  if (kcountHEpositivedirectionDigiD6 == 6)
6359  HEpositivedirectionDigiD6->SetXTitle("D for HE+ jeta = 23; depth = 6 \b");
6360  if (kcountHEpositivedirectionDigiD6 == 7)
6361  HEpositivedirectionDigiD6->SetXTitle("D for HE+ jeta = 24; depth = 6 \b");
6362  if (kcountHEpositivedirectionDigiD6 == 8)
6363  HEpositivedirectionDigiD6->SetXTitle("D for HE+ jeta = 25; depth = 6 \b");
6364  if (kcountHEpositivedirectionDigiD6 == 9)
6365  HEpositivedirectionDigiD6->SetXTitle("D for HE+ jeta = 26; depth = 6 \b");
6366  if (kcountHEpositivedirectionDigiD6 == 10)
6367  HEpositivedirectionDigiD6->SetXTitle("D for HE+ jeta = 27; depth = 6 \b");
6368  HEpositivedirectionDigiD6->Draw("Error");
6369  kcountHEpositivedirectionDigiD6++;
6370  if (kcountHEpositivedirectionDigiD6 > 10)
6371  break; // 4x6 = 24
6372  } //ccctest>0
6373 
6374  } // for i
6375  } //if(jeta-41 >= 0)
6376  } //for jeta
6378  c3x5->Update();
6379  c3x5->Print("DdigiPositiveDirectionhistD1PhiSymmetryDepth6HE.png");
6380  c3x5->Clear();
6381  // clean-up
6382  if (h2CeffHEpositivedirectionDigiD6)
6383  delete h2CeffHEpositivedirectionDigiD6;
6384  //========================================================================================== 20
6385  //======================================================================
6386  //======================================================================1D plot: D vs phi , different eta, depth=7
6387  //cout<<" 1D plot: D vs phi , different eta, depth=7 *****" <<endl;
6388  c3x5->Clear();
6389  c3x5->Divide(3, 5);
6390  c3x5->cd(1);
6391  int kcountHEpositivedirectionDigiD7 = 1;
6392  TH1F *h2CeffHEpositivedirectionDigiD7 = new TH1F("h2CeffHEpositivedirectionDigiD7", "", nphi, 0., 72.);
6393 
6394  for (int jeta = 0; jeta < njeta; jeta++) {
6395  // positivedirectionDigiD:
6396  if (jeta - 41 >= 0) {
6397  // for (int i=0;i<ndepth;i++) {
6398  // depth=7
6399  for (int i = 6; i < 7; i++) {
6400  TH1F *HEpositivedirectionDigiD7 = (TH1F *)h2CeffHEpositivedirectionDigiD7->Clone("twod1");
6401 
6402  float ccctest = 0; // to avoid empty massive elements
6403  for (int jphi = 0; jphi < nphi; jphi++) {
6404  double ccc1 = digivariancehe[i][jeta][jphi];
6405  if (adigihe[i][jeta][jphi] > 0.) {
6406  HEpositivedirectionDigiD7->Fill(jphi, ccc1);
6407  ccctest = 1.; //HEpositivedirectionDigiD7->SetBinError(i,0.01);
6408  }
6409  } // for jphi
6410  if (ccctest != 0.) {
6411  //cout<<"2020 kcountHEpositivedirectionDigiD7 = "<<kcountHEpositivedirectionDigiD7 <<" jeta-41= "<< jeta-41 <<endl;
6412  c3x5->cd(kcountHEpositivedirectionDigiD7);
6413  HEpositivedirectionDigiD7->SetMarkerStyle(20);
6414  HEpositivedirectionDigiD7->SetMarkerSize(0.4);
6415  HEpositivedirectionDigiD7->GetYaxis()->SetLabelSize(0.04);
6416  HEpositivedirectionDigiD7->SetXTitle("HEpositivedirectionDigiD7 \b");
6417  HEpositivedirectionDigiD7->SetMarkerColor(2);
6418  HEpositivedirectionDigiD7->SetLineColor(0);
6419  gPad->SetGridy();
6420  gPad->SetGridx();
6421  // gPad->SetLogy();
6422  if (kcountHEpositivedirectionDigiD7 == 1)
6423  HEpositivedirectionDigiD7->SetXTitle("D for HE+ jeta = 25; depth = 7 \b");
6424  if (kcountHEpositivedirectionDigiD7 == 2)
6425  HEpositivedirectionDigiD7->SetXTitle("D for HE+ jeta = 26; depth = 7 \b");
6426  if (kcountHEpositivedirectionDigiD7 == 3)
6427  HEpositivedirectionDigiD7->SetXTitle("D for HE+ jeta = 27; depth = 7 \b");
6428  HEpositivedirectionDigiD7->Draw("Error");
6429  kcountHEpositivedirectionDigiD7++;
6430  if (kcountHEpositivedirectionDigiD7 > 3)
6431  break; // 4x6 = 24
6432  } //ccctest>0
6433 
6434  } // for i
6435  } //if(jeta-41 >= 0)
6436  } //for jeta
6438  c3x5->Update();
6439  c3x5->Print("DdigiPositiveDirectionhistD1PhiSymmetryDepth7HE.png");
6440  c3x5->Clear();
6441  // clean-up
6442  if (h2CeffHEpositivedirectionDigiD7)
6443  delete h2CeffHEpositivedirectionDigiD7;
6444 
6445  //========================================================================================== 22222214
6446  //======================================================================
6447  //======================================================================1D plot: D vs phi , different eta, depth=1
6448  //cout<<" 1D plot: D vs phi , different eta, depth=1 *****" <<endl;
6449  c3x5->Clear();
6451  c3x5->Divide(3, 5);
6452  c3x5->cd(1);
6453  int kcountHEnegativedirectionDigiD1 = 1;
6454  TH1F *h2CeffHEnegativedirectionDigiD1 = new TH1F("h2CeffHEnegativedirectionDigiD1", "", nphi, 0., 72.);
6455 
6456  for (int jeta = 0; jeta < njeta; jeta++) {
6457  // negativedirectionDigiD:
6458  if (jeta - 41 < 0) {
6459  // for (int i=0;i<ndepth;i++) {
6460  // depth=1
6461  for (int i = 0; i < 1; i++) {
6462  TH1F *HEnegativedirectionDigiD1 = (TH1F *)h2CeffHEnegativedirectionDigiD1->Clone("twod1");
6463 
6464  float ccctest = 0; // to avoid empty massive elements
6465  for (int jphi = 0; jphi < nphi; jphi++) {
6466  double ccc1 = digivariancehe[i][jeta][jphi];
6467  if (adigihe[i][jeta][jphi] > 0.) {
6468  HEnegativedirectionDigiD1->Fill(jphi, ccc1);
6469  ccctest = 1.; //HEnegativedirectionDigiD1->SetBinError(i,0.01);
6470  }
6471  } // for jphi
6472  if (ccctest > 0.) {
6473  //cout<<"1414 kcountHEnegativedirectionDigiD1 = "<<kcountHEnegativedirectionDigiD1 <<" jeta-41= "<< jeta-41 <<endl;
6474  c3x5->cd(kcountHEnegativedirectionDigiD1);
6475  HEnegativedirectionDigiD1->SetMarkerStyle(20);
6476  HEnegativedirectionDigiD1->SetMarkerSize(0.4);
6477  HEnegativedirectionDigiD1->GetYaxis()->SetLabelSize(0.04);
6478  HEnegativedirectionDigiD1->SetXTitle("HEnegativedirectionDigiD1 \b");
6479  HEnegativedirectionDigiD1->SetMarkerColor(2);
6480  HEnegativedirectionDigiD1->SetLineColor(0);
6481  gPad->SetGridy();
6482  gPad->SetGridx();
6483  // gPad->SetLogy();
6484  if (kcountHEnegativedirectionDigiD1 == 1)
6485  HEnegativedirectionDigiD1->SetXTitle("D for HE- jeta =-29; depth = 1 \b");
6486  if (kcountHEnegativedirectionDigiD1 == 2)
6487  HEnegativedirectionDigiD1->SetXTitle("D for HE- jeta =-28; depth = 1 \b");
6488  if (kcountHEnegativedirectionDigiD1 == 3)
6489  HEnegativedirectionDigiD1->SetXTitle("D for HE- jeta =-27; depth = 1 \b");
6490  if (kcountHEnegativedirectionDigiD1 == 4)
6491  HEnegativedirectionDigiD1->SetXTitle("D for HE- jeta =-26; depth = 1 \b");
6492  if (kcountHEnegativedirectionDigiD1 == 5)
6493  HEnegativedirectionDigiD1->SetXTitle("D for HE- jeta =-25; depth = 1 \b");
6494  if (kcountHEnegativedirectionDigiD1 == 6)
6495  HEnegativedirectionDigiD1->SetXTitle("D for HE- jeta =-24; depth = 1 \b");
6496  if (kcountHEnegativedirectionDigiD1 == 7)
6497  HEnegativedirectionDigiD1->SetXTitle("D for HE- jeta =-23; depth = 1 \b");
6498  if (kcountHEnegativedirectionDigiD1 == 8)
6499  HEnegativedirectionDigiD1->SetXTitle("D for HE- jeta =-22; depth = 1 \b");
6500  if (kcountHEnegativedirectionDigiD1 == 9)
6501  HEnegativedirectionDigiD1->SetXTitle("D for HE- jeta =-21; depth = 1 \b");
6502  if (kcountHEnegativedirectionDigiD1 == 10)
6503  HEnegativedirectionDigiD1->SetXTitle("D for HE- jeta =-20; depth = 1 \b");
6504  if (kcountHEnegativedirectionDigiD1 == 11)
6505  HEnegativedirectionDigiD1->SetXTitle("D for HE- jeta =-19; depth = 1 \b");
6506  if (kcountHEnegativedirectionDigiD1 == 12)
6507  HEnegativedirectionDigiD1->SetXTitle("D for HE- jeta =-18; depth = 1 \b");
6508  HEnegativedirectionDigiD1->Draw("Error");
6509  kcountHEnegativedirectionDigiD1++;
6510  if (kcountHEnegativedirectionDigiD1 > 12)
6511  break; // 4x6 = 24
6512  } //ccctest>0
6513 
6514  } // for i
6515  } //if(jeta-41 < 0)
6516  } //for jeta
6518  c3x5->Update();
6519  c3x5->Print("DdigiNegativeDirectionhistD1PhiSymmetryDepth1HE.png");
6520  c3x5->Clear();
6521  // clean-up
6522  if (h2CeffHEnegativedirectionDigiD1)
6523  delete h2CeffHEnegativedirectionDigiD1;
6524  //========================================================================================== 22222215
6525  //======================================================================
6526  //======================================================================1D plot: D vs phi , different eta, depth=2
6527  //cout<<" 1D plot: D vs phi , different eta, depth=2 *****" <<endl;
6528  c3x5->Clear();
6529  c3x5->Divide(3, 5);
6530  c3x5->cd(1);
6531  int kcountHEnegativedirectionDigiD2 = 1;
6532  TH1F *h2CeffHEnegativedirectionDigiD2 = new TH1F("h2CeffHEnegativedirectionDigiD2", "", nphi, 0., 72.);
6533 
6534  for (int jeta = 0; jeta < njeta; jeta++) {
6535  // negativedirectionDigiD:
6536  if (jeta - 41 < 0) {
6537  // for (int i=0;i<ndepth;i++) {
6538  // depth=2
6539  for (int i = 1; i < 2; i++) {
6540  TH1F *HEnegativedirectionDigiD2 = (TH1F *)h2CeffHEnegativedirectionDigiD2->Clone("twod1");
6541 
6542  float ccctest = 0; // to avoid empty massive elements
6543  for (int jphi = 0; jphi < nphi; jphi++) {
6544  double ccc1 = digivariancehe[i][jeta][jphi];
6545  if (adigihe[i][jeta][jphi] > 0.) {
6546  HEnegativedirectionDigiD2->Fill(jphi, ccc1);
6547  ccctest = 1.; //HEnegativedirectionDigiD2->SetBinError(i,0.01);
6548  }
6549  } // for jphi
6550  if (ccctest > 0.) {
6551  //cout<<"1515 kcountHEnegativedirectionDigiD2 = "<<kcountHEnegativedirectionDigiD2 <<" jeta-41= "<< jeta-41 <<endl;
6552  c3x5->cd(kcountHEnegativedirectionDigiD2);
6553  HEnegativedirectionDigiD2->SetMarkerStyle(20);
6554  HEnegativedirectionDigiD2->SetMarkerSize(0.4);
6555  HEnegativedirectionDigiD2->GetYaxis()->SetLabelSize(0.04);
6556  HEnegativedirectionDigiD2->SetXTitle("HEnegativedirectionDigiD2 \b");
6557  HEnegativedirectionDigiD2->SetMarkerColor(2);
6558  HEnegativedirectionDigiD2->SetLineColor(0);
6559  gPad->SetGridy();
6560  gPad->SetGridx();
6561  // gPad->SetLogy();
6562  if (kcountHEnegativedirectionDigiD2 == 1)
6563  HEnegativedirectionDigiD2->SetXTitle("D for HE- jeta =-29; depth = 2 \b");
6564  if (kcountHEnegativedirectionDigiD2 == 2)
6565  HEnegativedirectionDigiD2->SetXTitle("D for HE- jeta =-28; depth = 2 \b");
6566  if (kcountHEnegativedirectionDigiD2 == 3)
6567  HEnegativedirectionDigiD2->SetXTitle("D for HE- jeta =-27; depth = 2 \b");
6568  if (kcountHEnegativedirectionDigiD2 == 4)
6569  HEnegativedirectionDigiD2->SetXTitle("D for HE- jeta =-26; depth = 2 \b");
6570  if (kcountHEnegativedirectionDigiD2 == 5)
6571  HEnegativedirectionDigiD2->SetXTitle("D for HE- jeta =-25; depth = 2 \b");
6572  if (kcountHEnegativedirectionDigiD2 == 6)
6573  HEnegativedirectionDigiD2->SetXTitle("D for HE- jeta =-24; depth = 2 \b");
6574  if (kcountHEnegativedirectionDigiD2 == 7)
6575  HEnegativedirectionDigiD2->SetXTitle("D for HE- jeta =-23; depth = 2 \b");
6576  if (kcountHEnegativedirectionDigiD2 == 8)
6577  HEnegativedirectionDigiD2->SetXTitle("D for HE- jeta =-22; depth = 2 \b");
6578  if (kcountHEnegativedirectionDigiD2 == 9)
6579  HEnegativedirectionDigiD2->SetXTitle("D for HE- jeta =-21; depth = 2 \b");
6580  if (kcountHEnegativedirectionDigiD2 == 10)
6581  HEnegativedirectionDigiD2->SetXTitle("D for HE- jeta =-20; depth = 2 \b");
6582  if (kcountHEnegativedirectionDigiD2 == 11)
6583  HEnegativedirectionDigiD2->SetXTitle("D for HE- jeta =-19; depth = 2 \b");
6584  if (kcountHEnegativedirectionDigiD2 == 12)
6585  HEnegativedirectionDigiD2->SetXTitle("D for HE- jeta =-18; depth = 2 \b");
6586  if (kcountHEnegativedirectionDigiD2 == 13)
6587  HEnegativedirectionDigiD2->SetXTitle("D for HE- jeta =-17; depth = 2 \b");
6588  HEnegativedirectionDigiD2->Draw("Error");
6589  kcountHEnegativedirectionDigiD2++;
6590  if (kcountHEnegativedirectionDigiD2 > 13)
6591  break; // 4x6 = 24
6592  } //ccctest>0
6593 
6594  } // for i
6595  } //if(jeta-41 < 0)
6596  } //for jeta
6598  c3x5->Update();
6599  c3x5->Print("DdigiNegativeDirectionhistD1PhiSymmetryDepth2HE.png");
6600  c3x5->Clear();
6601  // clean-up
6602  if (h2CeffHEnegativedirectionDigiD2)
6603  delete h2CeffHEnegativedirectionDigiD2;
6604  //========================================================================================== 22222216
6605  //======================================================================
6606  //======================================================================1D plot: D vs phi , different eta, depth=3
6607  //cout<<" 1D plot: D vs phi , different eta, depth=3 *****" <<endl;
6608  c3x5->Clear();
6609  c3x5->Divide(3, 5);
6610  c3x5->cd(1);
6611  int kcountHEnegativedirectionDigiD3 = 1;
6612  TH1F *h2CeffHEnegativedirectionDigiD3 = new TH1F("h2CeffHEnegativedirectionDigiD3", "", nphi, 0., 72.);
6613 
6614  for (int jeta = 0; jeta < njeta; jeta++) {
6615  // negativedirectionDigiD:
6616  if (jeta - 41 < 0) {
6617  // for (int i=0;i<ndepth;i++) {
6618  // depth=3
6619  for (int i = 2; i < 3; i++) {
6620  TH1F *HEnegativedirectionDigiD3 = (TH1F *)h2CeffHEnegativedirectionDigiD3->Clone("twod1");
6621 
6622  float ccctest = 0; // to avoid empty massive elements
6623  for (int jphi = 0; jphi < nphi; jphi++) {
6624  double ccc1 = digivariancehe[i][jeta][jphi];
6625  if (adigihe[i][jeta][jphi] > 0.) {
6626  HEnegativedirectionDigiD3->Fill(jphi, ccc1);
6627  ccctest = 1.; //HEnegativedirectionDigiD3->SetBinError(i,0.01);
6628  }
6629  } // for jphi
6630  if (ccctest > 0.) {
6631  //cout<<"1616 kcountHEnegativedirectionDigiD3 = "<<kcountHEnegativedirectionDigiD3 <<" jeta-41= "<< jeta-41 <<endl;
6632  c3x5->cd(kcountHEnegativedirectionDigiD3);
6633  HEnegativedirectionDigiD3->SetMarkerStyle(20);
6634  HEnegativedirectionDigiD3->SetMarkerSize(0.4);
6635  HEnegativedirectionDigiD3->GetYaxis()->SetLabelSize(0.04);
6636  HEnegativedirectionDigiD3->SetXTitle("HEnegativedirectionDigiD3 \b");
6637  HEnegativedirectionDigiD3->SetMarkerColor(2);
6638  HEnegativedirectionDigiD3->SetLineColor(0);
6639  gPad->SetGridy();
6640  gPad->SetGridx();
6641  // gPad->SetLogy();
6642  if (kcountHEnegativedirectionDigiD3 == 1)
6643  HEnegativedirectionDigiD3->SetXTitle("D for HE- jeta =-29; depth = 3 \b");
6644  if (kcountHEnegativedirectionDigiD3 == 2)
6645  HEnegativedirectionDigiD3->SetXTitle("D for HE- jeta =-28; depth = 3 \b");
6646  if (kcountHEnegativedirectionDigiD3 == 3)
6647  HEnegativedirectionDigiD3->SetXTitle("D for HE- jeta =-27; depth = 3 \b");
6648  if (kcountHEnegativedirectionDigiD3 == 4)
6649  HEnegativedirectionDigiD3->SetXTitle("D for HE- jeta =-26; depth = 3 \b");
6650  if (kcountHEnegativedirectionDigiD3 == 5)
6651  HEnegativedirectionDigiD3->SetXTitle("D for HE- jeta =-25; depth = 3 \b");
6652  if (kcountHEnegativedirectionDigiD3 == 6)
6653  HEnegativedirectionDigiD3->SetXTitle("D for HE- jeta =-24; depth = 3 \b");
6654  if (kcountHEnegativedirectionDigiD3 == 7)
6655  HEnegativedirectionDigiD3->SetXTitle("D for HE- jeta =-23; depth = 3 \b");
6656  if (kcountHEnegativedirectionDigiD3 == 8)
6657  HEnegativedirectionDigiD3->SetXTitle("D for HE- jeta =-22; depth = 3 \b");
6658  if (kcountHEnegativedirectionDigiD3 == 9)
6659  HEnegativedirectionDigiD3->SetXTitle("D for HE- jeta =-21; depth = 3 \b");
6660  if (kcountHEnegativedirectionDigiD3 == 10)
6661  HEnegativedirectionDigiD3->SetXTitle("D for HE- jeta =-20; depth = 3 \b");
6662  if (kcountHEnegativedirectionDigiD3 == 11)
6663  HEnegativedirectionDigiD3->SetXTitle("D for HE- jeta =-19; depth = 3 \b");
6664  if (kcountHEnegativedirectionDigiD3 == 12)
6665  HEnegativedirectionDigiD3->SetXTitle("D for HE- jeta =-18; depth = 3 \b");
6666  if (kcountHEnegativedirectionDigiD3 == 13)
6667  HEnegativedirectionDigiD3->SetXTitle("D for HE- jeta =-17; depth = 3 \b");
6668  HEnegativedirectionDigiD3->Draw("Error");
6669  kcountHEnegativedirectionDigiD3++;
6670  if (kcountHEnegativedirectionDigiD3 > 13)
6671  break; // 4x6 = 24
6672  } //ccctest>0
6673 
6674  } // for i
6675  } //if(jeta-41 < 0)
6676  } //for jeta
6678  c3x5->Update();
6679  c3x5->Print("DdigiNegativeDirectionhistD1PhiSymmetryDepth3HE.png");
6680  c3x5->Clear();
6681  // clean-up
6682  if (h2CeffHEnegativedirectionDigiD3)
6683  delete h2CeffHEnegativedirectionDigiD3;
6684  //========================================================================================== 22222217
6685  //======================================================================
6686  //======================================================================1D plot: D vs phi , different eta, depth=4
6687  //cout<<" 1D plot: D vs phi , different eta, depth=4 *****" <<endl;
6688  c3x5->Clear();
6689  c3x5->Divide(3, 5);
6690  c3x5->cd(1);
6691  int kcountHEnegativedirectionDigiD4 = 1;
6692  TH1F *h2CeffHEnegativedirectionDigiD4 = new TH1F("h2CeffHEnegativedirectionDigiD4", "", nphi, 0., 72.);
6693 
6694  for (int jeta = 0; jeta < njeta; jeta++) {
6695  // negativedirectionDigiD:
6696  if (jeta - 41 < 0) {
6697  // for (int i=0;i<ndepth;i++) {
6698  // depth=4
6699  for (int i = 3; i < 4; i++) {
6700  TH1F *HEnegativedirectionDigiD4 = (TH1F *)h2CeffHEnegativedirectionDigiD4->Clone("twod1");
6701 
6702  float ccctest = 0; // to avoid empty massive elements
6703  for (int jphi = 0; jphi < nphi; jphi++) {
6704  double ccc1 = digivariancehe[i][jeta][jphi];
6705  if (adigihe[i][jeta][jphi] > 0.) {
6706  HEnegativedirectionDigiD4->Fill(jphi, ccc1);
6707  ccctest = 1.; //HEnegativedirectionDigiD4->SetBinError(i,0.01);
6708  }
6709  } // for jphi
6710  if (ccctest > 0.) {
6711  //cout<<"1717 kcountHEnegativedirectionDigiD4 = "<<kcountHEnegativedirectionDigiD4 <<" jeta-41= "<< jeta-41 <<endl;
6712  c3x5->cd(kcountHEnegativedirectionDigiD4);
6713  HEnegativedirectionDigiD4->SetMarkerStyle(20);
6714  HEnegativedirectionDigiD4->SetMarkerSize(0.4);
6715  HEnegativedirectionDigiD4->GetYaxis()->SetLabelSize(0.04);
6716  HEnegativedirectionDigiD4->SetXTitle("HEnegativedirectionDigiD4 \b");
6717  HEnegativedirectionDigiD4->SetMarkerColor(2);
6718  HEnegativedirectionDigiD4->SetLineColor(0);
6719  gPad->SetGridy();
6720  gPad->SetGridx();
6721  // gPad->SetLogy();
6722  if (kcountHEnegativedirectionDigiD4 == 1)
6723  HEnegativedirectionDigiD4->SetXTitle("D for HE- jeta =-28; depth = 4 \b");
6724  if (kcountHEnegativedirectionDigiD4 == 2)
6725  HEnegativedirectionDigiD4->SetXTitle("D for HE- jeta =-27; depth = 4 \b");
6726  if (kcountHEnegativedirectionDigiD4 == 3)
6727  HEnegativedirectionDigiD4->SetXTitle("D for HE- jeta =-26; depth = 4 \b");
6728  if (kcountHEnegativedirectionDigiD4 == 4)
6729  HEnegativedirectionDigiD4->SetXTitle("D for HE- jeta =-25; depth = 4 \b");
6730  if (kcountHEnegativedirectionDigiD4 == 5)
6731  HEnegativedirectionDigiD4->SetXTitle("D for HE- jeta =-24; depth = 4 \b");
6732  if (kcountHEnegativedirectionDigiD4 == 6)
6733  HEnegativedirectionDigiD4->SetXTitle("D for HE- jeta =-23; depth = 4 \b");
6734  if (kcountHEnegativedirectionDigiD4 == 7)
6735  HEnegativedirectionDigiD4->SetXTitle("D for HE- jeta =-22; depth = 4 \b");
6736  if (kcountHEnegativedirectionDigiD4 == 8)
6737  HEnegativedirectionDigiD4->SetXTitle("D for HE- jeta =-21; depth = 4 \b");
6738  if (kcountHEnegativedirectionDigiD4 == 9)
6739  HEnegativedirectionDigiD4->SetXTitle("D for HE- jeta =-20; depth = 4 \b");
6740  if (kcountHEnegativedirectionDigiD4 == 10)
6741  HEnegativedirectionDigiD4->SetXTitle("D for HE- jeta =-19; depth = 4 \b");
6742  if (kcountHEnegativedirectionDigiD4 == 11)
6743  HEnegativedirectionDigiD4->SetXTitle("D for HE- jeta =-18; depth = 4 \b");
6744  if (kcountHEnegativedirectionDigiD4 == 12)
6745  HEnegativedirectionDigiD4->SetXTitle("D for HE- jeta =-16; depth = 4 \b");
6746  HEnegativedirectionDigiD4->Draw("Error");
6747  kcountHEnegativedirectionDigiD4++;
6748  if (kcountHEnegativedirectionDigiD4 > 12)
6749  break; // 4x6 = 24
6750  } //ccctest>0
6751 
6752  } // for i
6753  } //if(jeta-41 < 0)
6754  } //for jeta
6756  c3x5->Update();
6757  c3x5->Print("DdigiNegativeDirectionhistD1PhiSymmetryDepth4HE.png");
6758  c3x5->Clear();
6759  // clean-up
6760  if (h2CeffHEnegativedirectionDigiD4)
6761  delete h2CeffHEnegativedirectionDigiD4;
6762  //========================================================================================== 22222218
6763  //======================================================================
6764  //======================================================================1D plot: D vs phi , different eta, depth=5
6765  //cout<<" 1D plot: D vs phi , different eta, depth=5 *****" <<endl;
6766  c3x5->Clear();
6767  c3x5->Divide(3, 5);
6768  c3x5->cd(1);
6769  int kcountHEnegativedirectionDigiD5 = 1;
6770  TH1F *h2CeffHEnegativedirectionDigiD5 = new TH1F("h2CeffHEnegativedirectionDigiD5", "", nphi, 0., 72.);
6771 
6772  for (int jeta = 0; jeta < njeta; jeta++) {
6773  // negativedirectionDigiD:
6774  if (jeta - 41 < 0) {
6775  // for (int i=0;i<ndepth;i++) {
6776  // depth=5
6777  for (int i = 4; i < 5; i++) {
6778  TH1F *HEnegativedirectionDigiD5 = (TH1F *)h2CeffHEnegativedirectionDigiD5->Clone("twod1");
6779 
6780  float ccctest = 0; // to avoid empty massive elements
6781  for (int jphi = 0; jphi < nphi; jphi++) {
6782  double ccc1 = digivariancehe[i][jeta][jphi];
6783  if (adigihe[i][jeta][jphi] > 0.) {
6784  HEnegativedirectionDigiD5->Fill(jphi, ccc1);
6785  ccctest = 1.; //HEnegativedirectionDigiD5->SetBinError(i,0.01);
6786  }
6787  } // for jphi
6788  if (ccctest > 0.) {
6789  //cout<<"1818 kcountHEnegativedirectionDigiD5 = "<<kcountHEnegativedirectionDigiD5 <<" jeta-41= "<< jeta-41 <<endl;
6790  c3x5->cd(kcountHEnegativedirectionDigiD5);
6791  HEnegativedirectionDigiD5->SetMarkerStyle(20);
6792  HEnegativedirectionDigiD5->SetMarkerSize(0.4);
6793  HEnegativedirectionDigiD5->GetYaxis()->SetLabelSize(0.04);
6794  HEnegativedirectionDigiD5->SetXTitle("HEnegativedirectionDigiD5 \b");
6795  HEnegativedirectionDigiD5->SetMarkerColor(2);
6796  HEnegativedirectionDigiD5->SetLineColor(0);
6797  gPad->SetGridy();
6798  gPad->SetGridx();
6799  // gPad->SetLogy();
6800  if (kcountHEnegativedirectionDigiD5 == 1)
6801  HEnegativedirectionDigiD5->SetXTitle("D for HE- jeta =-28; depth = 5 \b");
6802  if (kcountHEnegativedirectionDigiD5 == 2)
6803  HEnegativedirectionDigiD5->SetXTitle("D for HE- jeta =-27; depth = 5 \b");
6804  if (kcountHEnegativedirectionDigiD5 == 3)
6805  HEnegativedirectionDigiD5->SetXTitle("D for HE- jeta =-26; depth = 5 \b");
6806  if (kcountHEnegativedirectionDigiD5 == 4)
6807  HEnegativedirectionDigiD5->SetXTitle("D for HE- jeta =-25; depth = 5 \b");
6808  if (kcountHEnegativedirectionDigiD5 == 5)
6809  HEnegativedirectionDigiD5->SetXTitle("D for HE- jeta =-24; depth = 5 \b");
6810  if (kcountHEnegativedirectionDigiD5 == 6)
6811  HEnegativedirectionDigiD5->SetXTitle("D for HE- jeta =-23; depth = 5 \b");
6812  if (kcountHEnegativedirectionDigiD5 == 7)
6813  HEnegativedirectionDigiD5->SetXTitle("D for HE- jeta =-22; depth = 5 \b");
6814  if (kcountHEnegativedirectionDigiD5 == 8)
6815  HEnegativedirectionDigiD5->SetXTitle("D for HE- jeta =-21; depth = 5 \b");
6816  if (kcountHEnegativedirectionDigiD5 == 9)
6817  HEnegativedirectionDigiD5->SetXTitle("D for HE- jeta =-20; depth = 5 \b");
6818  if (kcountHEnegativedirectionDigiD5 == 10)
6819  HEnegativedirectionDigiD5->SetXTitle("D for HE- jeta =-19; depth = 5 \b");
6820  if (kcountHEnegativedirectionDigiD5 == 11)
6821  HEnegativedirectionDigiD5->SetXTitle("D for HE- jeta =-18; depth = 5 \b");
6822  HEnegativedirectionDigiD5->Draw("Error");
6823  kcountHEnegativedirectionDigiD5++;
6824  if (kcountHEnegativedirectionDigiD5 > 11)
6825  break; // 4x6 = 24
6826  } //ccctest>0
6827 
6828  } // for i
6829  } //if(jeta-41 < 0)
6830  } //for jeta
6832  c3x5->Update();
6833  c3x5->Print("DdigiNegativeDirectionhistD1PhiSymmetryDepth5HE.png");
6834  c3x5->Clear();
6835  // clean-up
6836  if (h2CeffHEnegativedirectionDigiD5)
6837  delete h2CeffHEnegativedirectionDigiD5;
6838  //========================================================================================== 22222219
6839  //======================================================================
6840  //======================================================================1D plot: D vs phi , different eta, depth=6
6841  //cout<<" 1D plot: D vs phi , different eta, depth=6 *****" <<endl;
6842  c3x5->Clear();
6843  c3x5->Divide(3, 5);
6844  c3x5->cd(1);
6845  int kcountHEnegativedirectionDigiD6 = 1;
6846  TH1F *h2CeffHEnegativedirectionDigiD6 = new TH1F("h2CeffHEnegativedirectionDigiD6", "", nphi, 0., 72.);
6847 
6848  for (int jeta = 0; jeta < njeta; jeta++) {
6849  // negativedirectionDigiD:
6850  if (jeta - 41 < 0) {
6851  // for (int i=0;i<ndepth;i++) {
6852  // depth=6
6853  for (int i = 5; i < 6; i++) {
6854  TH1F *HEnegativedirectionDigiD6 = (TH1F *)h2CeffHEnegativedirectionDigiD6->Clone("twod1");
6855 
6856  float ccctest = 0; // to avoid empty massive elements
6857  for (int jphi = 0; jphi < nphi; jphi++) {
6858  double ccc1 = digivariancehe[i][jeta][jphi];
6859  if (adigihe[i][jeta][jphi] > 0.) {
6860  HEnegativedirectionDigiD6->Fill(jphi, ccc1);
6861  ccctest = 1.; //HEnegativedirectionDigiD6->SetBinError(i,0.01);
6862  }
6863  } // for jphi
6864  if (ccctest > 0.) {
6865  //cout<<"1919 kcountHEnegativedirectionDigiD6 = "<<kcountHEnegativedirectionDigiD6 <<" jeta-41= "<< jeta-41 <<endl;
6866  c3x5->cd(kcountHEnegativedirectionDigiD6);
6867  HEnegativedirectionDigiD6->SetMarkerStyle(20);
6868  HEnegativedirectionDigiD6->SetMarkerSize(0.4);
6869  HEnegativedirectionDigiD6->GetYaxis()->SetLabelSize(0.04);
6870  HEnegativedirectionDigiD6->SetXTitle("HEnegativedirectionDigiD6 \b");
6871  HEnegativedirectionDigiD6->SetMarkerColor(2);
6872  HEnegativedirectionDigiD6->SetLineColor(0);
6873  gPad->SetGridy();
6874  gPad->SetGridx();
6875  // gPad->SetLogy();
6876  if (kcountHEnegativedirectionDigiD6 == 1)
6877  HEnegativedirectionDigiD6->SetXTitle("D for HE- jeta =-28; depth = 6 \b");
6878  if (kcountHEnegativedirectionDigiD6 == 2)
6879  HEnegativedirectionDigiD6->SetXTitle("D for HE- jeta =-27; depth = 6 \b");
6880  if (kcountHEnegativedirectionDigiD6 == 3)
6881  HEnegativedirectionDigiD6->SetXTitle("D for HE- jeta =-26; depth = 6 \b");
6882  if (kcountHEnegativedirectionDigiD6 == 4)
6883  HEnegativedirectionDigiD6->SetXTitle("D for HE- jeta =-25; depth = 6 \b");
6884  if (kcountHEnegativedirectionDigiD6 == 5)
6885  HEnegativedirectionDigiD6->SetXTitle("D for HE- jeta =-24; depth = 6 \b");
6886  if (kcountHEnegativedirectionDigiD6 == 6)
6887  HEnegativedirectionDigiD6->SetXTitle("D for HE- jeta =-23; depth = 6 \b");
6888  if (kcountHEnegativedirectionDigiD6 == 7)
6889  HEnegativedirectionDigiD6->SetXTitle("D for HE- jeta =-22; depth = 6 \b");
6890  if (kcountHEnegativedirectionDigiD6 == 8)
6891  HEnegativedirectionDigiD6->SetXTitle("D for HE- jeta =-21; depth = 6 \b");
6892  if (kcountHEnegativedirectionDigiD6 == 9)
6893  HEnegativedirectionDigiD6->SetXTitle("D for HE- jeta =-20; depth = 6 \b");
6894  if (kcountHEnegativedirectionDigiD6 == 10)
6895  HEnegativedirectionDigiD6->SetXTitle("D for HE- jeta =-19; depth = 6 \b");
6896  HEnegativedirectionDigiD6->Draw("Error");
6897  kcountHEnegativedirectionDigiD6++;
6898  if (kcountHEnegativedirectionDigiD6 > 10)
6899  break; // 4x6 = 24
6900  } //ccctest>0
6901 
6902  } // for i
6903  } //if(jeta-41 < 0)
6904  } //for jeta
6906  c3x5->Update();
6907  c3x5->Print("DdigiNegativeDirectionhistD1PhiSymmetryDepth6HE.png");
6908  c3x5->Clear();
6909  // clean-up
6910  if (h2CeffHEnegativedirectionDigiD6)
6911  delete h2CeffHEnegativedirectionDigiD6;
6912  //========================================================================================== 22222220
6913  //======================================================================
6914  //======================================================================1D plot: D vs phi , different eta, depth=7
6915  //cout<<" 1D plot: D vs phi , different eta, depth=7 *****" <<endl;
6916  c3x5->Clear();
6917  c3x5->Divide(3, 5);
6918  c3x5->cd(1);
6919  int kcountHEnegativedirectionDigiD7 = 1;
6920  TH1F *h2CeffHEnegativedirectionDigiD7 = new TH1F("h2CeffHEnegativedirectionDigiD7", "", nphi, 0., 72.);
6921 
6922  for (int jeta = 0; jeta < njeta; jeta++) {
6923  // negativedirectionDigiD:
6924  if (jeta - 41 < 0) {
6925  // for (int i=0;i<ndepth;i++) {
6926  // depth=7
6927  for (int i = 6; i < 7; i++) {
6928  TH1F *HEnegativedirectionDigiD7 = (TH1F *)h2CeffHEnegativedirectionDigiD7->Clone("twod1");
6929 
6930  float ccctest = 0; // to avoid empty massive elements
6931  for (int jphi = 0; jphi < nphi; jphi++) {
6932  double ccc1 = digivariancehe[i][jeta][jphi];
6933  if (adigihe[i][jeta][jphi] > 0.) {
6934  HEnegativedirectionDigiD7->Fill(jphi, ccc1);
6935  ccctest = 1.; //HEnegativedirectionDigiD7->SetBinError(i,0.01);
6936  }
6937  } // for jphi
6938  if (ccctest != 0.) {
6939  //cout<<"2020 kcountHEnegativedirectionDigiD7 = "<<kcountHEnegativedirectionDigiD7 <<" jeta-41= "<< jeta-41 <<endl;
6940  c3x5->cd(kcountHEnegativedirectionDigiD7);
6941  HEnegativedirectionDigiD7->SetMarkerStyle(20);
6942  HEnegativedirectionDigiD7->SetMarkerSize(0.4);
6943  HEnegativedirectionDigiD7->GetYaxis()->SetLabelSize(0.04);
6944  HEnegativedirectionDigiD7->SetXTitle("HEnegativedirectionDigiD7 \b");
6945  HEnegativedirectionDigiD7->SetMarkerColor(2);
6946  HEnegativedirectionDigiD7->SetLineColor(0);
6947  gPad->SetGridy();
6948  gPad->SetGridx();
6949  // gPad->SetLogy();
6950  if (kcountHEnegativedirectionDigiD7 == 1)
6951  HEnegativedirectionDigiD7->SetXTitle("D for HE- jeta =-28; depth = 7 \b");
6952  if (kcountHEnegativedirectionDigiD7 == 2)
6953  HEnegativedirectionDigiD7->SetXTitle("D for HE- jeta =-27; depth = 7 \b");
6954  if (kcountHEnegativedirectionDigiD7 == 3)
6955  HEnegativedirectionDigiD7->SetXTitle("D for HE- jeta =-26; depth = 7 \b");
6956  HEnegativedirectionDigiD7->Draw("Error");
6957  kcountHEnegativedirectionDigiD7++;
6958  if (kcountHEnegativedirectionDigiD7 > 3)
6959  break; // 4x6 = 24
6960  } //ccctest>0
6961 
6962  } // for i
6963  } //if(jeta-41 < 0)
6964  } //for jeta
6966  c3x5->Update();
6967  c3x5->Print("DdigiNegativeDirectionhistD1PhiSymmetryDepth7HE.png");
6968  c3x5->Clear();
6969  // clean-up
6970  if (h2CeffHEnegativedirectionDigiD7)
6971  delete h2CeffHEnegativedirectionDigiD7;
6972  //===================================================================== END of Digi HE for phi-symmetry
6973  //===================================================================== END of Digi HE for phi-symmetry
6974  //===================================================================== END of Digi HE for phi-symmetry
6975 
6979  // int k_max[5]={0,4,7,4,4}; // maximum depth for each subdet
6980  //ndepth = k_max[5];
6981  ndepth = 4;
6982  double adigiHF[ndepth][njeta][njphi];
6983  double digivarianceHF[ndepth][njeta][njphi];
6984  // RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR: Digi HF
6985  TH2F *amplitudechannel1HF1 = (TH2F *)dir->FindObjectAny("h_amplitudechannel1_HF1");
6986  TH2F *amplitudechannel0HF1 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HF1");
6987  TH2F *amplitudechannelHF1 = (TH2F *)amplitudechannel1HF1->Clone("amplitudechannelHF1");
6988  amplitudechannelHF1->Divide(amplitudechannel1HF1, amplitudechannel0HF1, 1, 1, "B");
6989  TH2F *amplitudechannel1HF2 = (TH2F *)dir->FindObjectAny("h_amplitudechannel1_HF2");
6990  TH2F *amplitudechannel0HF2 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HF2");
6991  TH2F *amplitudechannelHF2 = (TH2F *)amplitudechannel1HF2->Clone("amplitudechannelHF2");
6992  amplitudechannelHF2->Divide(amplitudechannel1HF2, amplitudechannel0HF2, 1, 1, "B");
6993  TH2F *amplitudechannel1HF3 = (TH2F *)dir->FindObjectAny("h_amplitudechannel1_HF3");
6994  TH2F *amplitudechannel0HF3 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HF3");
6995  TH2F *amplitudechannelHF3 = (TH2F *)amplitudechannel1HF3->Clone("amplitudechannelHF3");
6996  amplitudechannelHF3->Divide(amplitudechannel1HF3, amplitudechannel0HF3, 1, 1, "B");
6997  TH2F *amplitudechannel1HF4 = (TH2F *)dir->FindObjectAny("h_amplitudechannel1_HF4");
6998  TH2F *amplitudechannel0HF4 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HF4");
6999  TH2F *amplitudechannelHF4 = (TH2F *)amplitudechannel1HF4->Clone("amplitudechannelHF4");
7000  amplitudechannelHF4->Divide(amplitudechannel1HF4, amplitudechannel0HF4, 1, 1, "B");
7001  for (int jeta = 0; jeta < njeta; jeta++) {
7002  //====================================================================== PHI normalization & put R into massive adigiHF
7003  //preparation for PHI normalization:
7004  double sumdigiHF0 = 0;
7005  int nsumdigiHF0 = 0;
7006  double sumdigiHF1 = 0;
7007  int nsumdigiHF1 = 0;
7008  double sumdigiHF2 = 0;
7009  int nsumdigiHF2 = 0;
7010  double sumdigiHF3 = 0;
7011  int nsumdigiHF3 = 0;
7012  for (int jphi = 0; jphi < njphi; jphi++) {
7013  adigiHF[0][jeta][jphi] = amplitudechannelHF1->GetBinContent(jeta + 1, jphi + 1);
7014  adigiHF[1][jeta][jphi] = amplitudechannelHF2->GetBinContent(jeta + 1, jphi + 1);
7015  adigiHF[2][jeta][jphi] = amplitudechannelHF3->GetBinContent(jeta + 1, jphi + 1);
7016  adigiHF[3][jeta][jphi] = amplitudechannelHF4->GetBinContent(jeta + 1, jphi + 1);
7017  if (adigiHF[0][jeta][jphi] > 0.) {
7018  sumdigiHF0 += adigiHF[0][jeta][jphi];
7019  ++nsumdigiHF0;
7020  }
7021  if (adigiHF[1][jeta][jphi] > 0.) {
7022  sumdigiHF1 += adigiHF[1][jeta][jphi];
7023  ++nsumdigiHF1;
7024  }
7025  if (adigiHF[2][jeta][jphi] > 0.) {
7026  sumdigiHF2 += adigiHF[2][jeta][jphi];
7027  ++nsumdigiHF2;
7028  }
7029  if (adigiHF[3][jeta][jphi] > 0.) {
7030  sumdigiHF3 += adigiHF[3][jeta][jphi];
7031  ++nsumdigiHF3;
7032  }
7033  } // phi
7034  // PHI normalization:
7035  for (int jphi = 0; jphi < njphi; jphi++) {
7036  if (adigiHF[0][jeta][jphi] > 0.)
7037  adigiHF[0][jeta][jphi] /= (sumdigiHF0 / nsumdigiHF0);
7038  if (adigiHF[1][jeta][jphi] > 0.)
7039  adigiHF[1][jeta][jphi] /= (sumdigiHF1 / nsumdigiHF1);
7040  if (adigiHF[2][jeta][jphi] > 0.)
7041  adigiHF[2][jeta][jphi] /= (sumdigiHF2 / nsumdigiHF2);
7042  if (adigiHF[3][jeta][jphi] > 0.)
7043  adigiHF[3][jeta][jphi] /= (sumdigiHF3 / nsumdigiHF3);
7044  } // phi
7045  } //eta
7046  //------------------------ 2D-eta/phi-plot: R, averaged over depthfs
7047  //======================================================================
7048  //======================================================================
7049  //cout<<" R2D-eta/phi-plot: R, averaged over depthfs *****" <<endl;
7050  c1x0->Clear();
7052  c1x0->Divide(1, 1);
7053  c1x0->cd(1);
7054  TH2F *GefzRdigiHF42D = new TH2F("GefzRdigiHF42D", "", neta, -41., 41., nphi, 0., 72.);
7055  TH2F *GefzRdigiHF42D0 = new TH2F("GefzRdigiHF42D0", "", neta, -41., 41., nphi, 0., 72.);
7056  TH2F *GefzRdigiHF42DF = (TH2F *)GefzRdigiHF42D0->Clone("GefzRdigiHF42DF");
7057  for (int i = 0; i < ndepth; i++) {
7058  for (int jeta = 0; jeta < neta; jeta++) {
7059  for (int jphi = 0; jphi < nphi; jphi++) {
7060  double ccc1 = adigiHF[i][jeta][jphi];
7061  int k2plot = jeta - 41;
7062  int kkk = k2plot; //if(k2plot >0 ) kkk=k2plot+1; //-41 +41 !=0
7063  if (ccc1 != 0.) {
7064  GefzRdigiHF42D->Fill(kkk, jphi, ccc1);
7065  GefzRdigiHF42D0->Fill(kkk, jphi, 1.);
7066  }
7067  }
7068  }
7069  }
7070  GefzRdigiHF42DF->Divide(GefzRdigiHF42D, GefzRdigiHF42D0, 1, 1, "B"); // average A
7071  gPad->SetGridy();
7072  gPad->SetGridx(); // gPad->SetLogz();
7073  GefzRdigiHF42DF->SetMarkerStyle(20);
7074  GefzRdigiHF42DF->SetMarkerSize(0.4);
7075  GefzRdigiHF42DF->GetZaxis()->SetLabelSize(0.08);
7076  GefzRdigiHF42DF->SetXTitle("<R>_depth #eta \b");
7077  GefzRdigiHF42DF->SetYTitle(" #phi \b");
7078  GefzRdigiHF42DF->SetZTitle("<R>_depth \b");
7079  GefzRdigiHF42DF->SetMarkerColor(2);
7080  GefzRdigiHF42DF->SetLineColor(
7081  0); // GefzRdigiHF42DF->SetMaximum(1.000); // GefzRdigiHF42DF->SetMinimum(1.0);
7082  GefzRdigiHF42DF->Draw("COLZ");
7084  c1x0->Update();
7085  c1x0->Print("RdigiGeneralD2PhiSymmetryHF.png");
7086  c1x0->Clear();
7087  // clean-up
7088  if (GefzRdigiHF42D)
7089  delete GefzRdigiHF42D;
7090  if (GefzRdigiHF42D0)
7091  delete GefzRdigiHF42D0;
7092  if (GefzRdigiHF42DF)
7093  delete GefzRdigiHF42DF;
7094  //====================================================================== 1D plot: R vs phi , averaged over depthfs & eta
7095  //======================================================================
7096  //cout<<" 1D plot: R vs phi , averaged over depthfs & eta *****" <<endl;
7097  c1x1->Clear();
7099  c1x1->Divide(1, 1);
7100  c1x1->cd(1);
7101  TH1F *GefzRdigiHF41D = new TH1F("GefzRdigiHF41D", "", nphi, 0., 72.);
7102  TH1F *GefzRdigiHF41D0 = new TH1F("GefzRdigiHF41D0", "", nphi, 0., 72.);
7103  TH1F *GefzRdigiHF41DF = (TH1F *)GefzRdigiHF41D0->Clone("GefzRdigiHF41DF");
7104  for (int jphi = 0; jphi < nphi; jphi++) {
7105  for (int jeta = 0; jeta < neta; jeta++) {
7106  for (int i = 0; i < ndepth; i++) {
7107  double ccc1 = adigiHF[i][jeta][jphi];
7108  if (ccc1 != 0.) {
7109  GefzRdigiHF41D->Fill(jphi, ccc1);
7110  GefzRdigiHF41D0->Fill(jphi, 1.);
7111  }
7112  }
7113  }
7114  }
7115  GefzRdigiHF41DF->Divide(GefzRdigiHF41D, GefzRdigiHF41D0, 1, 1, "B"); // R averaged over depthfs & eta
7116  GefzRdigiHF41D0->Sumw2();
7117  // for (int jphi=1;jphi<73;jphi++) {GefzRdigiHF41DF->SetBinError(jphi,0.01);}
7118  gPad->SetGridy();
7119  gPad->SetGridx(); // gPad->SetLogz();
7120  GefzRdigiHF41DF->SetMarkerStyle(20);
7121  GefzRdigiHF41DF->SetMarkerSize(1.4);
7122  GefzRdigiHF41DF->GetZaxis()->SetLabelSize(0.08);
7123  GefzRdigiHF41DF->SetXTitle("#phi \b");
7124  GefzRdigiHF41DF->SetYTitle(" <R> \b");
7125  GefzRdigiHF41DF->SetZTitle("<R>_PHI - AllDepthfs \b");
7126  GefzRdigiHF41DF->SetMarkerColor(4);
7127  GefzRdigiHF41DF->SetLineColor(
7128  4); // GefzRdigiHF41DF->SetMinimum(0.8); // GefzRdigiHF41DF->SetMaximum(1.000);
7129  GefzRdigiHF41DF->Draw("Error");
7131  c1x1->Update();
7132  c1x1->Print("RdigiGeneralD1PhiSymmetryHF.png");
7133  c1x1->Clear();
7134  // clean-up
7135  if (GefzRdigiHF41D)
7136  delete GefzRdigiHF41D;
7137  if (GefzRdigiHF41D0)
7138  delete GefzRdigiHF41D0;
7139  if (GefzRdigiHF41DF)
7140  delete GefzRdigiHF41DF;
7141  //========================================================================================== 4
7142  //======================================================================
7143  //======================================================================1D plot: R vs phi , different eta, depth=1
7144  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
7145  c3x5->Clear();
7147  c3x5->Divide(3, 5);
7148  c3x5->cd(1);
7149  int kcountHFpositivedirectionDigi1 = 1;
7150  TH1F *h2CeffHFpositivedirectionDigi1 = new TH1F("h2CeffHFpositivedirectionDigi1", "", nphi, 0., 72.);
7151  for (int jeta = 0; jeta < njeta; jeta++) {
7152  // positivedirectionDigi:
7153  if (jeta - 41 >= 0) {
7154  // for (int i=0;i<ndepth;i++) {
7155  // depth=1
7156  for (int i = 0; i < 1; i++) {
7157  TH1F *HFpositivedirectionDigi1 = (TH1F *)h2CeffHFpositivedirectionDigi1->Clone("twod1");
7158  float ccctest = 0; // to avoid empty massive elements
7159  for (int jphi = 0; jphi < nphi; jphi++) {
7160  double ccc1 = adigiHF[i][jeta][jphi];
7161  if (ccc1 != 0.) {
7162  HFpositivedirectionDigi1->Fill(jphi, ccc1);
7163  ccctest = 1.; //HFpositivedirectionDigi1->SetBinError(i,0.01);
7164  }
7165  } // for jphi
7166  if (ccctest > 0.) {
7167  // cout<<"444 kcountHFpositivedirectionDigi1 = "<<kcountHFpositivedirectionDigi1 <<" jeta-41= "<< jeta-41 <<endl;
7168  c3x5->cd(kcountHFpositivedirectionDigi1);
7169  HFpositivedirectionDigi1->SetMarkerStyle(20);
7170  HFpositivedirectionDigi1->SetMarkerSize(0.4);
7171  HFpositivedirectionDigi1->GetYaxis()->SetLabelSize(0.04);
7172  HFpositivedirectionDigi1->SetXTitle("HFpositivedirectionDigi1 \b");
7173  HFpositivedirectionDigi1->SetMarkerColor(2);
7174  HFpositivedirectionDigi1->SetLineColor(0);
7175  gPad->SetGridy();
7176  gPad->SetGridx();
7177  // gPad->SetLogy();
7178  if (kcountHFpositivedirectionDigi1 == 1)
7179  HFpositivedirectionDigi1->SetXTitle("R for HF+ jeta = 28; depth = 1 \b");
7180  if (kcountHFpositivedirectionDigi1 == 2)
7181  HFpositivedirectionDigi1->SetXTitle("R for HF+ jeta = 29; depth = 1 \b");
7182  if (kcountHFpositivedirectionDigi1 == 3)
7183  HFpositivedirectionDigi1->SetXTitle("R for HF+ jeta = 30; depth = 1 \b");
7184  if (kcountHFpositivedirectionDigi1 == 4)
7185  HFpositivedirectionDigi1->SetXTitle("R for HF+ jeta = 31; depth = 1 \b");
7186  if (kcountHFpositivedirectionDigi1 == 5)
7187  HFpositivedirectionDigi1->SetXTitle("R for HF+ jeta = 32; depth = 1 \b");
7188  if (kcountHFpositivedirectionDigi1 == 6)
7189  HFpositivedirectionDigi1->SetXTitle("R for HF+ jeta = 33; depth = 1 \b");
7190  if (kcountHFpositivedirectionDigi1 == 7)
7191  HFpositivedirectionDigi1->SetXTitle("R for HF+ jeta = 34; depth = 1 \b");
7192  if (kcountHFpositivedirectionDigi1 == 8)
7193  HFpositivedirectionDigi1->SetXTitle("R for HF+ jeta = 35; depth = 1 \b");
7194  if (kcountHFpositivedirectionDigi1 == 9)
7195  HFpositivedirectionDigi1->SetXTitle("R for HF+ jeta = 36; depth = 1 \b");
7196  if (kcountHFpositivedirectionDigi1 == 10)
7197  HFpositivedirectionDigi1->SetXTitle("R for HF+ jeta = 37; depth = 1 \b");
7198  if (kcountHFpositivedirectionDigi1 == 11)
7199  HFpositivedirectionDigi1->SetXTitle("R for HF+ jeta = 38; depth = 1 \b");
7200  if (kcountHFpositivedirectionDigi1 == 12)
7201  HFpositivedirectionDigi1->SetXTitle("R for HF+ jeta = 39; depth = 1 \b");
7202  if (kcountHFpositivedirectionDigi1 == 13)
7203  HFpositivedirectionDigi1->SetXTitle("R for HF+ jeta = 40; depth = 1 \b");
7204  HFpositivedirectionDigi1->Draw("Error");
7205  kcountHFpositivedirectionDigi1++;
7206  if (kcountHFpositivedirectionDigi1 > 13)
7207  break; //
7208  } //ccctest>0
7209 
7210  } // for i
7211  } //if(jeta-41 >= 0)
7212  } //for jeta
7214  c3x5->Update();
7215  c3x5->Print("RdigiPositiveDirectionhistD1PhiSymmetryDepth1HF.png");
7216  c3x5->Clear();
7217  // clean-up
7218  if (h2CeffHFpositivedirectionDigi1)
7219  delete h2CeffHFpositivedirectionDigi1;
7220 
7221  //========================================================================================== 5
7222  //======================================================================
7223  //======================================================================1D plot: R vs phi , different eta, depth=2
7224  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
7225  c3x5->Clear();
7227  c3x5->Divide(3, 5);
7228  c3x5->cd(1);
7229  int kcountHFpositivedirectionDigi2 = 1;
7230  TH1F *h2CeffHFpositivedirectionDigi2 = new TH1F("h2CeffHFpositivedirectionDigi2", "", nphi, 0., 72.);
7231  for (int jeta = 0; jeta < njeta; jeta++) {
7232  // positivedirectionDigi:
7233  if (jeta - 41 >= 0) {
7234  // for (int i=0;i<ndepth;i++) {
7235  // depth=2
7236  for (int i = 1; i < 2; i++) {
7237  TH1F *HFpositivedirectionDigi2 = (TH1F *)h2CeffHFpositivedirectionDigi2->Clone("twod1");
7238  float ccctest = 0; // to avoid empty massive elements
7239  for (int jphi = 0; jphi < nphi; jphi++) {
7240  double ccc1 = adigiHF[i][jeta][jphi];
7241  if (ccc1 != 0.) {
7242  HFpositivedirectionDigi2->Fill(jphi, ccc1);
7243  ccctest = 1.; //HFpositivedirectionDigi2->SetBinError(i,0.01);
7244  }
7245  } // for jphi
7246  if (ccctest > 0.) {
7247  //cout<<"555 kcountHFpositivedirectionDigi2 = "<<kcountHFpositivedirectionDigi2 <<" jeta-41= "<< jeta-41 <<endl;
7248  c3x5->cd(kcountHFpositivedirectionDigi2);
7249  HFpositivedirectionDigi2->SetMarkerStyle(20);
7250  HFpositivedirectionDigi2->SetMarkerSize(0.4);
7251  HFpositivedirectionDigi2->GetYaxis()->SetLabelSize(0.04);
7252  HFpositivedirectionDigi2->SetXTitle("HFpositivedirectionDigi2 \b");
7253  HFpositivedirectionDigi2->SetMarkerColor(2);
7254  HFpositivedirectionDigi2->SetLineColor(0);
7255  gPad->SetGridy();
7256  gPad->SetGridx();
7257  // gPad->SetLogy();
7258  if (kcountHFpositivedirectionDigi2 == 1)
7259  HFpositivedirectionDigi2->SetXTitle("R for HF+ jeta = 28; depth = 2 \b");
7260  if (kcountHFpositivedirectionDigi2 == 2)
7261  HFpositivedirectionDigi2->SetXTitle("R for HF+ jeta = 29; depth = 2 \b");
7262  if (kcountHFpositivedirectionDigi2 == 3)
7263  HFpositivedirectionDigi2->SetXTitle("R for HF+ jeta = 30; depth = 2 \b");
7264  if (kcountHFpositivedirectionDigi2 == 4)
7265  HFpositivedirectionDigi2->SetXTitle("R for HF+ jeta = 31; depth = 2 \b");
7266  if (kcountHFpositivedirectionDigi2 == 5)
7267  HFpositivedirectionDigi2->SetXTitle("R for HF+ jeta = 32; depth = 2 \b");
7268  if (kcountHFpositivedirectionDigi2 == 6)
7269  HFpositivedirectionDigi2->SetXTitle("R for HF+ jeta = 33; depth = 2 \b");
7270  if (kcountHFpositivedirectionDigi2 == 7)
7271  HFpositivedirectionDigi2->SetXTitle("R for HF+ jeta = 34; depth = 2 \b");
7272  if (kcountHFpositivedirectionDigi2 == 8)
7273  HFpositivedirectionDigi2->SetXTitle("R for HF+ jeta = 35; depth = 2 \b");
7274  if (kcountHFpositivedirectionDigi2 == 9)
7275  HFpositivedirectionDigi2->SetXTitle("R for HF+ jeta = 36; depth = 2 \b");
7276  if (kcountHFpositivedirectionDigi2 == 10)
7277  HFpositivedirectionDigi2->SetXTitle("R for HF+ jeta = 37; depth = 2 \b");
7278  if (kcountHFpositivedirectionDigi2 == 11)
7279  HFpositivedirectionDigi2->SetXTitle("R for HF+ jeta = 38; depth = 2 \b");
7280  if (kcountHFpositivedirectionDigi2 == 12)
7281  HFpositivedirectionDigi2->SetXTitle("R for HF+ jeta = 39; depth = 2 \b");
7282  if (kcountHFpositivedirectionDigi2 == 13)
7283  HFpositivedirectionDigi2->SetXTitle("R for HF+ jeta = 40; depth = 2 \b");
7284  HFpositivedirectionDigi2->Draw("Error");
7285  kcountHFpositivedirectionDigi2++;
7286  if (kcountHFpositivedirectionDigi2 > 13)
7287  break; // 4x6 = 24
7288  } //ccctest>0
7289 
7290  } // for i
7291  } //if(jeta-41 >= 0)
7292  } //for jeta
7294  c3x5->Update();
7295  c3x5->Print("RdigiPositiveDirectionhistD1PhiSymmetryDepth2HF.png");
7296  c3x5->Clear();
7297  // clean-up
7298  if (h2CeffHFpositivedirectionDigi2)
7299  delete h2CeffHFpositivedirectionDigi2;
7300  //========================================================================================== 6
7301  //======================================================================
7302  //======================================================================1D plot: R vs phi , different eta, depth=3
7303  //cout<<" 1D plot: R vs phi , different eta, depth=3 *****" <<endl;
7304  c3x5->Clear();
7306  c3x5->Divide(3, 5);
7307  c3x5->cd(1);
7308  int kcountHFpositivedirectionDigi3 = 1;
7309  TH1F *h2CeffHFpositivedirectionDigi3 = new TH1F("h2CeffHFpositivedirectionDigi3", "", nphi, 0., 72.);
7310  for (int jeta = 0; jeta < njeta; jeta++) {
7311  // positivedirectionDigi:
7312  if (jeta - 41 >= 0) {
7313  // for (int i=0;i<ndepth;i++) {
7314  // depth=3
7315  for (int i = 2; i < 3; i++) {
7316  TH1F *HFpositivedirectionDigi3 = (TH1F *)h2CeffHFpositivedirectionDigi3->Clone("twod1");
7317  float ccctest = 0; // to avoid empty massive elements
7318  for (int jphi = 0; jphi < nphi; jphi++) {
7319  double ccc1 = adigiHF[i][jeta][jphi];
7320  if (ccc1 != 0.) {
7321  HFpositivedirectionDigi3->Fill(jphi, ccc1);
7322  ccctest = 1.; //HFpositivedirectionDigi3->SetBinError(i,0.01);
7323  }
7324  } // for jphi
7325  if (ccctest > 0.) {
7326  //cout<<"666 kcountHFpositivedirectionDigi3 = "<<kcountHFpositivedirectionDigi3 <<" jeta-41= "<< jeta-41 <<endl;
7327  c3x5->cd(kcountHFpositivedirectionDigi3);
7328  HFpositivedirectionDigi3->SetMarkerStyle(20);
7329  HFpositivedirectionDigi3->SetMarkerSize(0.4);
7330  HFpositivedirectionDigi3->GetYaxis()->SetLabelSize(0.04);
7331  HFpositivedirectionDigi3->SetXTitle("HFpositivedirectionDigi3 \b");
7332  HFpositivedirectionDigi3->SetMarkerColor(2);
7333  HFpositivedirectionDigi3->SetLineColor(0);
7334  gPad->SetGridy();
7335  gPad->SetGridx();
7336  // gPad->SetLogy();
7337  if (kcountHFpositivedirectionDigi3 == 1)
7338  HFpositivedirectionDigi3->SetXTitle("R for HF+ jeta = 28; depth = 3 \b");
7339  if (kcountHFpositivedirectionDigi3 == 2)
7340  HFpositivedirectionDigi3->SetXTitle("R for HF+ jeta = 29; depth = 3 \b");
7341  if (kcountHFpositivedirectionDigi3 == 3)
7342  HFpositivedirectionDigi3->SetXTitle("R for HF+ jeta = 30; depth = 3 \b");
7343  if (kcountHFpositivedirectionDigi3 == 4)
7344  HFpositivedirectionDigi3->SetXTitle("R for HF+ jeta = 31; depth = 3 \b");
7345  if (kcountHFpositivedirectionDigi3 == 5)
7346  HFpositivedirectionDigi3->SetXTitle("R for HF+ jeta = 32; depth = 3 \b");
7347  if (kcountHFpositivedirectionDigi3 == 6)
7348  HFpositivedirectionDigi3->SetXTitle("R for HF+ jeta = 33; depth = 3 \b");
7349  if (kcountHFpositivedirectionDigi3 == 7)
7350  HFpositivedirectionDigi3->SetXTitle("R for HF+ jeta = 34; depth = 3 \b");
7351  if (kcountHFpositivedirectionDigi3 == 8)
7352  HFpositivedirectionDigi3->SetXTitle("R for HF+ jeta = 35; depth = 3 \b");
7353  if (kcountHFpositivedirectionDigi3 == 9)
7354  HFpositivedirectionDigi3->SetXTitle("R for HF+ jeta = 36; depth = 3 \b");
7355  if (kcountHFpositivedirectionDigi3 == 10)
7356  HFpositivedirectionDigi3->SetXTitle("R for HF+ jeta = 37; depth = 3 \b");
7357  if (kcountHFpositivedirectionDigi3 == 11)
7358  HFpositivedirectionDigi3->SetXTitle("R for HF+ jeta = 38; depth = 3 \b");
7359  if (kcountHFpositivedirectionDigi3 == 12)
7360  HFpositivedirectionDigi3->SetXTitle("R for HF+ jeta = 39; depth = 3 \b");
7361  if (kcountHFpositivedirectionDigi3 == 13)
7362  HFpositivedirectionDigi3->SetXTitle("R for HF+ jeta = 40; depth = 3 \b");
7363  HFpositivedirectionDigi3->Draw("Error");
7364  kcountHFpositivedirectionDigi3++;
7365  if (kcountHFpositivedirectionDigi3 > 13)
7366  break; // 4x6 = 24
7367  } //ccctest>0
7368 
7369  } // for i
7370  } //if(jeta-41 >= 0)
7371  } //for jeta
7373  c3x5->Update();
7374  c3x5->Print("RdigiPositiveDirectionhistD1PhiSymmetryDepth3HF.png");
7375  c3x5->Clear();
7376  // clean-up
7377  if (h2CeffHFpositivedirectionDigi3)
7378  delete h2CeffHFpositivedirectionDigi3;
7379  //========================================================================================== 7
7380  //======================================================================
7381  //======================================================================1D plot: R vs phi , different eta, depth=4
7382  //cout<<" 1D plot: R vs phi , different eta, depth=4 *****" <<endl;
7383  c3x5->Clear();
7385  c3x5->Divide(3, 5);
7386  c3x5->cd(1);
7387  int kcountHFpositivedirectionDigi4 = 1;
7388  TH1F *h2CeffHFpositivedirectionDigi4 = new TH1F("h2CeffHFpositivedirectionDigi4", "", nphi, 0., 72.);
7389 
7390  for (int jeta = 0; jeta < njeta; jeta++) {
7391  // positivedirectionDigi:
7392  if (jeta - 41 >= 0) {
7393  // for (int i=0;i<ndepth;i++) {
7394  // depth=4
7395  for (int i = 3; i < 4; i++) {
7396  TH1F *HFpositivedirectionDigi4 = (TH1F *)h2CeffHFpositivedirectionDigi4->Clone("twod1");
7397 
7398  float ccctest = 0; // to avoid empty massive elements
7399  for (int jphi = 0; jphi < nphi; jphi++) {
7400  double ccc1 = adigiHF[i][jeta][jphi];
7401  if (ccc1 != 0.) {
7402  HFpositivedirectionDigi4->Fill(jphi, ccc1);
7403  ccctest = 1.; //HFpositivedirectionDigi4->SetBinError(i,0.01);
7404  }
7405  } // for jphi
7406  if (ccctest > 0.) {
7407  //cout<<"777 kcountHFpositivedirectionDigi4 = "<<kcountHFpositivedirectionDigi4 <<" jeta-41= "<< jeta-41 <<endl;
7408  c3x5->cd(kcountHFpositivedirectionDigi4);
7409  HFpositivedirectionDigi4->SetMarkerStyle(20);
7410  HFpositivedirectionDigi4->SetMarkerSize(0.4);
7411  HFpositivedirectionDigi4->GetYaxis()->SetLabelSize(0.04);
7412  HFpositivedirectionDigi4->SetXTitle("HFpositivedirectionDigi4 \b");
7413  HFpositivedirectionDigi4->SetMarkerColor(2);
7414  HFpositivedirectionDigi4->SetLineColor(0);
7415  gPad->SetGridy();
7416  gPad->SetGridx();
7417  // gPad->SetLogy();
7418  if (kcountHFpositivedirectionDigi4 == 1)
7419  HFpositivedirectionDigi4->SetXTitle("R for HF+ jeta = 28; depth = 4 \b");
7420  if (kcountHFpositivedirectionDigi4 == 2)
7421  HFpositivedirectionDigi4->SetXTitle("R for HF+ jeta = 29; depth = 4 \b");
7422  if (kcountHFpositivedirectionDigi4 == 3)
7423  HFpositivedirectionDigi4->SetXTitle("R for HF+ jeta = 30; depth = 4 \b");
7424  if (kcountHFpositivedirectionDigi4 == 4)
7425  HFpositivedirectionDigi4->SetXTitle("R for HF+ jeta = 31; depth = 4 \b");
7426  if (kcountHFpositivedirectionDigi4 == 5)
7427  HFpositivedirectionDigi4->SetXTitle("R for HF+ jeta = 32; depth = 4 \b");
7428  if (kcountHFpositivedirectionDigi4 == 6)
7429  HFpositivedirectionDigi4->SetXTitle("R for HF+ jeta = 33; depth = 4 \b");
7430  if (kcountHFpositivedirectionDigi4 == 7)
7431  HFpositivedirectionDigi4->SetXTitle("R for HF+ jeta = 34; depth = 4 \b");
7432  if (kcountHFpositivedirectionDigi4 == 8)
7433  HFpositivedirectionDigi4->SetXTitle("R for HF+ jeta = 35; depth = 4 \b");
7434  if (kcountHFpositivedirectionDigi4 == 9)
7435  HFpositivedirectionDigi4->SetXTitle("R for HF+ jeta = 36; depth = 4 \b");
7436  if (kcountHFpositivedirectionDigi4 == 10)
7437  HFpositivedirectionDigi4->SetXTitle("R for HF+ jeta = 37; depth = 4 \b");
7438  if (kcountHFpositivedirectionDigi4 == 11)
7439  HFpositivedirectionDigi4->SetXTitle("R for HF+ jeta = 38; depth = 4 \b");
7440  if (kcountHFpositivedirectionDigi4 == 12)
7441  HFpositivedirectionDigi4->SetXTitle("R for HF+ jeta = 39; depth = 4 \b");
7442  if (kcountHFpositivedirectionDigi4 == 13)
7443  HFpositivedirectionDigi4->SetXTitle("R for HF+ jeta = 40; depth = 4 \b");
7444  HFpositivedirectionDigi4->Draw("Error");
7445  kcountHFpositivedirectionDigi4++;
7446  if (kcountHFpositivedirectionDigi4 > 13)
7447  break; // 4x6 = 24
7448  } //ccctest>0
7449 
7450  } // for i
7451  } //if(jeta-41 >= 0)
7452  } //for jeta
7454  c3x5->Update();
7455  c3x5->Print("RdigiPositiveDirectionhistD1PhiSymmetryDepth4HF.png");
7456  c3x5->Clear();
7457  // clean-up
7458  if (h2CeffHFpositivedirectionDigi4)
7459  delete h2CeffHFpositivedirectionDigi4;
7460 
7461  //========================================================================================== 1111114
7462  //======================================================================
7463  //======================================================================1D plot: R vs phi , different eta, depth=1
7464  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
7465  c3x5->Clear();
7467  c3x5->Divide(3, 5);
7468  c3x5->cd(1);
7469  int kcountHFnegativedirectionDigi1 = 1;
7470  TH1F *h2CeffHFnegativedirectionDigi1 = new TH1F("h2CeffHFnegativedirectionDigi1", "", nphi, 0., 72.);
7471  for (int jeta = 0; jeta < njeta; jeta++) {
7472  // negativedirectionDigi:
7473  if (jeta - 41 < 0) {
7474  // for (int i=0;i<ndepth;i++) {
7475  // depth=1
7476  for (int i = 0; i < 1; i++) {
7477  TH1F *HFnegativedirectionDigi1 = (TH1F *)h2CeffHFnegativedirectionDigi1->Clone("twod1");
7478  float ccctest = 0; // to avoid empty massive elements
7479  for (int jphi = 0; jphi < nphi; jphi++) {
7480  double ccc1 = adigiHF[i][jeta][jphi];
7481  if (ccc1 != 0.) {
7482  HFnegativedirectionDigi1->Fill(jphi, ccc1);
7483  ccctest = 1.; //HFnegativedirectionDigi1->SetBinError(i,0.01);
7484  }
7485  } // for jphi
7486  if (ccctest > 0.) {
7487  // cout<<"444 kcountHFnegativedirectionDigi1 = "<<kcountHFnegativedirectionDigi1 <<" jeta-41= "<< jeta-41 <<endl;
7488  c3x5->cd(kcountHFnegativedirectionDigi1);
7489  HFnegativedirectionDigi1->SetMarkerStyle(20);
7490  HFnegativedirectionDigi1->SetMarkerSize(0.4);
7491  HFnegativedirectionDigi1->GetYaxis()->SetLabelSize(0.04);
7492  HFnegativedirectionDigi1->SetXTitle("HFnegativedirectionDigi1 \b");
7493  HFnegativedirectionDigi1->SetMarkerColor(2);
7494  HFnegativedirectionDigi1->SetLineColor(0);
7495  gPad->SetGridy();
7496  gPad->SetGridx();
7497  // gPad->SetLogy();
7498  if (kcountHFnegativedirectionDigi1 == 1)
7499  HFnegativedirectionDigi1->SetXTitle("R for HF- jeta =-41; depth = 1 \b");
7500  if (kcountHFnegativedirectionDigi1 == 2)
7501  HFnegativedirectionDigi1->SetXTitle("R for HF- jeta =-40; depth = 1 \b");
7502  if (kcountHFnegativedirectionDigi1 == 3)
7503  HFnegativedirectionDigi1->SetXTitle("R for HF- jeta =-39; depth = 1 \b");
7504  if (kcountHFnegativedirectionDigi1 == 4)
7505  HFnegativedirectionDigi1->SetXTitle("R for HF- jeta =-38; depth = 1 \b");
7506  if (kcountHFnegativedirectionDigi1 == 5)
7507  HFnegativedirectionDigi1->SetXTitle("R for HF- jeta =-37; depth = 1 \b");
7508  if (kcountHFnegativedirectionDigi1 == 6)
7509  HFnegativedirectionDigi1->SetXTitle("R for HF- jeta =-36; depth = 1 \b");
7510  if (kcountHFnegativedirectionDigi1 == 7)
7511  HFnegativedirectionDigi1->SetXTitle("R for HF- jeta =-35; depth = 1 \b");
7512  if (kcountHFnegativedirectionDigi1 == 8)
7513  HFnegativedirectionDigi1->SetXTitle("R for HF- jeta =-34; depth = 1 \b");
7514  if (kcountHFnegativedirectionDigi1 == 9)
7515  HFnegativedirectionDigi1->SetXTitle("R for HF- jeta =-33; depth = 1 \b");
7516  if (kcountHFnegativedirectionDigi1 == 10)
7517  HFnegativedirectionDigi1->SetXTitle("R for HF- jeta =-32; depth = 1 \b");
7518  if (kcountHFnegativedirectionDigi1 == 11)
7519  HFnegativedirectionDigi1->SetXTitle("R for HF- jeta =-31; depth = 1 \b");
7520  if (kcountHFnegativedirectionDigi1 == 12)
7521  HFnegativedirectionDigi1->SetXTitle("R for HF- jeta =-30; depth = 1 \b");
7522  if (kcountHFnegativedirectionDigi1 == 13)
7523  HFnegativedirectionDigi1->SetXTitle("R for HF- jeta =-29; depth = 1 \b");
7524  HFnegativedirectionDigi1->Draw("Error");
7525  kcountHFnegativedirectionDigi1++;
7526  if (kcountHFnegativedirectionDigi1 > 13)
7527  break; //
7528  } //ccctest>0
7529 
7530  } // for i
7531  } //if(jeta-41< 0)
7532  } //for jeta
7534  c3x5->Update();
7535  c3x5->Print("RdigiNegativeDirectionhistD1PhiSymmetryDepth1HF.png");
7536  c3x5->Clear();
7537  // clean-up
7538  if (h2CeffHFnegativedirectionDigi1)
7539  delete h2CeffHFnegativedirectionDigi1;
7540 
7541  //========================================================================================== 1111115
7542  //======================================================================
7543  //======================================================================1D plot: R vs phi , different eta, depth=2
7544  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
7545  c3x5->Clear();
7547  c3x5->Divide(3, 5);
7548  c3x5->cd(1);
7549  int kcountHFnegativedirectionDigi2 = 1;
7550  TH1F *h2CeffHFnegativedirectionDigi2 = new TH1F("h2CeffHFnegativedirectionDigi2", "", nphi, 0., 72.);
7551  for (int jeta = 0; jeta < njeta; jeta++) {
7552  // negativedirectionDigi:
7553  if (jeta - 41 < 0) {
7554  // for (int i=0;i<ndepth;i++) {
7555  // depth=2
7556  for (int i = 1; i < 2; i++) {
7557  TH1F *HFnegativedirectionDigi2 = (TH1F *)h2CeffHFnegativedirectionDigi2->Clone("twod1");
7558  float ccctest = 0; // to avoid empty massive elements
7559  for (int jphi = 0; jphi < nphi; jphi++) {
7560  double ccc1 = adigiHF[i][jeta][jphi];
7561  if (ccc1 != 0.) {
7562  HFnegativedirectionDigi2->Fill(jphi, ccc1);
7563  ccctest = 1.; //HFnegativedirectionDigi2->SetBinError(i,0.01);
7564  }
7565  } // for jphi
7566  if (ccctest > 0.) {
7567  //cout<<"555 kcountHFnegativedirectionDigi2 = "<<kcountHFnegativedirectionDigi2 <<" jeta-41= "<< jeta-41 <<endl;
7568  c3x5->cd(kcountHFnegativedirectionDigi2);
7569  HFnegativedirectionDigi2->SetMarkerStyle(20);
7570  HFnegativedirectionDigi2->SetMarkerSize(0.4);
7571  HFnegativedirectionDigi2->GetYaxis()->SetLabelSize(0.04);
7572  HFnegativedirectionDigi2->SetXTitle("HFnegativedirectionDigi2 \b");
7573  HFnegativedirectionDigi2->SetMarkerColor(2);
7574  HFnegativedirectionDigi2->SetLineColor(0);
7575  gPad->SetGridy();
7576  gPad->SetGridx();
7577  // gPad->SetLogy();
7578  if (kcountHFnegativedirectionDigi2 == 1)
7579  HFnegativedirectionDigi2->SetXTitle("R for HF- jeta =-41; depth = 2 \b");
7580  if (kcountHFnegativedirectionDigi2 == 2)
7581  HFnegativedirectionDigi2->SetXTitle("R for HF- jeta =-40; depth = 2 \b");
7582  if (kcountHFnegativedirectionDigi2 == 3)
7583  HFnegativedirectionDigi2->SetXTitle("R for HF- jeta =-39; depth = 2 \b");
7584  if (kcountHFnegativedirectionDigi2 == 4)
7585  HFnegativedirectionDigi2->SetXTitle("R for HF- jeta =-38; depth = 2 \b");
7586  if (kcountHFnegativedirectionDigi2 == 5)
7587  HFnegativedirectionDigi2->SetXTitle("R for HF- jeta =-37; depth = 2 \b");
7588  if (kcountHFnegativedirectionDigi2 == 6)
7589  HFnegativedirectionDigi2->SetXTitle("R for HF- jeta =-36; depth = 2 \b");
7590  if (kcountHFnegativedirectionDigi2 == 7)
7591  HFnegativedirectionDigi2->SetXTitle("R for HF- jeta =-35; depth = 2 \b");
7592  if (kcountHFnegativedirectionDigi2 == 8)
7593  HFnegativedirectionDigi2->SetXTitle("R for HF- jeta =-34; depth = 2 \b");
7594  if (kcountHFnegativedirectionDigi2 == 9)
7595  HFnegativedirectionDigi2->SetXTitle("R for HF- jeta =-33; depth = 2 \b");
7596  if (kcountHFnegativedirectionDigi2 == 10)
7597  HFnegativedirectionDigi2->SetXTitle("R for HF- jeta =-32; depth = 2 \b");
7598  if (kcountHFnegativedirectionDigi2 == 11)
7599  HFnegativedirectionDigi2->SetXTitle("R for HF- jeta =-31; depth = 2 \b");
7600  if (kcountHFnegativedirectionDigi2 == 12)
7601  HFnegativedirectionDigi2->SetXTitle("R for HF- jeta =-30; depth = 2 \b");
7602  if (kcountHFnegativedirectionDigi2 == 13)
7603  HFnegativedirectionDigi2->SetXTitle("R for HF- jeta =-20; depth = 2 \b");
7604  HFnegativedirectionDigi2->Draw("Error");
7605  kcountHFnegativedirectionDigi2++;
7606  if (kcountHFnegativedirectionDigi2 > 13)
7607  break; // 4x6 = 24
7608  } //ccctest>0
7609 
7610  } // for i
7611  } //if(jeta-41< 0)
7612  } //for jeta
7614  c3x5->Update();
7615  c3x5->Print("RdigiNegativeDirectionhistD1PhiSymmetryDepth2HF.png");
7616  c3x5->Clear();
7617  // clean-up
7618  if (h2CeffHFnegativedirectionDigi2)
7619  delete h2CeffHFnegativedirectionDigi2;
7620  //========================================================================================== 1111116
7621  //======================================================================
7622  //======================================================================1D plot: R vs phi , different eta, depth=3
7623  //cout<<" 1D plot: R vs phi , different eta, depth=3 *****" <<endl;
7624  c3x5->Clear();
7626  c3x5->Divide(3, 5);
7627  c3x5->cd(1);
7628  int kcountHFnegativedirectionDigi3 = 1;
7629  TH1F *h2CeffHFnegativedirectionDigi3 = new TH1F("h2CeffHFnegativedirectionDigi3", "", nphi, 0., 72.);
7630  for (int jeta = 0; jeta < njeta; jeta++) {
7631  // negativedirectionDigi:
7632  if (jeta - 41 < 0) {
7633  // for (int i=0;i<ndepth;i++) {
7634  // depth=3
7635  for (int i = 2; i < 3; i++) {
7636  TH1F *HFnegativedirectionDigi3 = (TH1F *)h2CeffHFnegativedirectionDigi3->Clone("twod1");
7637  float ccctest = 0; // to avoid empty massive elements
7638  for (int jphi = 0; jphi < nphi; jphi++) {
7639  double ccc1 = adigiHF[i][jeta][jphi];
7640  if (ccc1 != 0.) {
7641  HFnegativedirectionDigi3->Fill(jphi, ccc1);
7642  ccctest = 1.; //HFnegativedirectionDigi3->SetBinError(i,0.01);
7643  }
7644  } // for jphi
7645  if (ccctest > 0.) {
7646  //cout<<"666 kcountHFnegativedirectionDigi3 = "<<kcountHFnegativedirectionDigi3 <<" jeta-41= "<< jeta-41 <<endl;
7647  c3x5->cd(kcountHFnegativedirectionDigi3);
7648  HFnegativedirectionDigi3->SetMarkerStyle(20);
7649  HFnegativedirectionDigi3->SetMarkerSize(0.4);
7650  HFnegativedirectionDigi3->GetYaxis()->SetLabelSize(0.04);
7651  HFnegativedirectionDigi3->SetXTitle("HFnegativedirectionDigi3 \b");
7652  HFnegativedirectionDigi3->SetMarkerColor(2);
7653  HFnegativedirectionDigi3->SetLineColor(0);
7654  gPad->SetGridy();
7655  gPad->SetGridx();
7656  // gPad->SetLogy();
7657  if (kcountHFnegativedirectionDigi3 == 1)
7658  HFnegativedirectionDigi3->SetXTitle("R for HF- jeta =-41; depth = 3 \b");
7659  if (kcountHFnegativedirectionDigi3 == 2)
7660  HFnegativedirectionDigi3->SetXTitle("R for HF- jeta =-40; depth = 3 \b");
7661  if (kcountHFnegativedirectionDigi3 == 3)
7662  HFnegativedirectionDigi3->SetXTitle("R for HF- jeta =-39; depth = 3 \b");
7663  if (kcountHFnegativedirectionDigi3 == 4)
7664  HFnegativedirectionDigi3->SetXTitle("R for HF- jeta =-38; depth = 3 \b");
7665  if (kcountHFnegativedirectionDigi3 == 5)
7666  HFnegativedirectionDigi3->SetXTitle("R for HF- jeta =-37; depth = 3 \b");
7667  if (kcountHFnegativedirectionDigi3 == 6)
7668  HFnegativedirectionDigi3->SetXTitle("R for HF- jeta =-36; depth = 3 \b");
7669  if (kcountHFnegativedirectionDigi3 == 7)
7670  HFnegativedirectionDigi3->SetXTitle("R for HF- jeta =-35; depth = 3 \b");
7671  if (kcountHFnegativedirectionDigi3 == 8)
7672  HFnegativedirectionDigi3->SetXTitle("R for HF- jeta =-34; depth = 3 \b");
7673  if (kcountHFnegativedirectionDigi3 == 9)
7674  HFnegativedirectionDigi3->SetXTitle("R for HF- jeta =-33; depth = 3 \b");
7675  if (kcountHFnegativedirectionDigi3 == 10)
7676  HFnegativedirectionDigi3->SetXTitle("R for HF- jeta =-32; depth = 3 \b");
7677  if (kcountHFnegativedirectionDigi3 == 11)
7678  HFnegativedirectionDigi3->SetXTitle("R for HF- jeta =-31; depth = 3 \b");
7679  if (kcountHFnegativedirectionDigi3 == 12)
7680  HFnegativedirectionDigi3->SetXTitle("R for HF- jeta =-30; depth = 3 \b");
7681  if (kcountHFnegativedirectionDigi3 == 13)
7682  HFnegativedirectionDigi3->SetXTitle("R for HF- jeta =-29; depth = 3 \b");
7683  HFnegativedirectionDigi3->Draw("Error");
7684  kcountHFnegativedirectionDigi3++;
7685  if (kcountHFnegativedirectionDigi3 > 13)
7686  break; // 4x6 = 24
7687  } //ccctest>0
7688 
7689  } // for i
7690  } //if(jeta-41< 0)
7691  } //for jeta
7693  c3x5->Update();
7694  c3x5->Print("RdigiNegativeDirectionhistD1PhiSymmetryDepth3HF.png");
7695  c3x5->Clear();
7696  // clean-up
7697  if (h2CeffHFnegativedirectionDigi3)
7698  delete h2CeffHFnegativedirectionDigi3;
7699  //========================================================================================== 1111117
7700  //======================================================================
7701  //======================================================================1D plot: R vs phi , different eta, depth=4
7702  //cout<<" 1D plot: R vs phi , different eta, depth=4 *****" <<endl;
7703  c3x5->Clear();
7705  c3x5->Divide(3, 5);
7706  c3x5->cd(1);
7707  int kcountHFnegativedirectionDigi4 = 1;
7708  TH1F *h2CeffHFnegativedirectionDigi4 = new TH1F("h2CeffHFnegativedirectionDigi4", "", nphi, 0., 72.);
7709 
7710  for (int jeta = 0; jeta < njeta; jeta++) {
7711  // negativedirectionDigi:
7712  if (jeta - 41 < 0) {
7713  // for (int i=0;i<ndepth;i++) {
7714  // depth=4
7715  for (int i = 3; i < 4; i++) {
7716  TH1F *HFnegativedirectionDigi4 = (TH1F *)h2CeffHFnegativedirectionDigi4->Clone("twod1");
7717 
7718  float ccctest = 0; // to avoid empty massive elements
7719  for (int jphi = 0; jphi < nphi; jphi++) {
7720  double ccc1 = adigiHF[i][jeta][jphi];
7721  if (ccc1 != 0.) {
7722  HFnegativedirectionDigi4->Fill(jphi, ccc1);
7723  ccctest = 1.; //HFnegativedirectionDigi4->SetBinError(i,0.01);
7724  }
7725  } // for jphi
7726  if (ccctest > 0.) {
7727  //cout<<"777 kcountHFnegativedirectionDigi4 = "<<kcountHFnegativedirectionDigi4 <<" jeta-41= "<< jeta-41 <<endl;
7728  c3x5->cd(kcountHFnegativedirectionDigi4);
7729  HFnegativedirectionDigi4->SetMarkerStyle(20);
7730  HFnegativedirectionDigi4->SetMarkerSize(0.4);
7731  HFnegativedirectionDigi4->GetYaxis()->SetLabelSize(0.04);
7732  HFnegativedirectionDigi4->SetXTitle("HFnegativedirectionDigi4 \b");
7733  HFnegativedirectionDigi4->SetMarkerColor(2);
7734  HFnegativedirectionDigi4->SetLineColor(0);
7735  gPad->SetGridy();
7736  gPad->SetGridx();
7737  // gPad->SetLogy();
7738  if (kcountHFnegativedirectionDigi4 == 1)
7739  HFnegativedirectionDigi4->SetXTitle("R for HF- jeta =-41; depth = 4 \b");
7740  if (kcountHFnegativedirectionDigi4 == 2)
7741  HFnegativedirectionDigi4->SetXTitle("R for HF- jeta =-40; depth = 4 \b");
7742  if (kcountHFnegativedirectionDigi4 == 3)
7743  HFnegativedirectionDigi4->SetXTitle("R for HF- jeta =-39; depth = 4 \b");
7744  if (kcountHFnegativedirectionDigi4 == 4)
7745  HFnegativedirectionDigi4->SetXTitle("R for HF- jeta =-38; depth = 4 \b");
7746  if (kcountHFnegativedirectionDigi4 == 5)
7747  HFnegativedirectionDigi4->SetXTitle("R for HF- jeta =-37; depth = 4 \b");
7748  if (kcountHFnegativedirectionDigi4 == 6)
7749  HFnegativedirectionDigi4->SetXTitle("R for HF- jeta =-36; depth = 4 \b");
7750  if (kcountHFnegativedirectionDigi4 == 7)
7751  HFnegativedirectionDigi4->SetXTitle("R for HF- jeta =-35; depth = 4 \b");
7752  if (kcountHFnegativedirectionDigi4 == 8)
7753  HFnegativedirectionDigi4->SetXTitle("R for HF- jeta =-34; depth = 4 \b");
7754  if (kcountHFnegativedirectionDigi4 == 9)
7755  HFnegativedirectionDigi4->SetXTitle("R for HF- jeta =-33; depth = 4 \b");
7756  if (kcountHFnegativedirectionDigi4 == 10)
7757  HFnegativedirectionDigi4->SetXTitle("R for HF- jeta =-32; depth = 4 \b");
7758  if (kcountHFnegativedirectionDigi4 == 11)
7759  HFnegativedirectionDigi4->SetXTitle("R for HF- jeta =-31; depth = 4 \b");
7760  if (kcountHFnegativedirectionDigi4 == 12)
7761  HFnegativedirectionDigi4->SetXTitle("R for HF- jeta =-30; depth = 4 \b");
7762  if (kcountHFnegativedirectionDigi4 == 13)
7763  HFnegativedirectionDigi4->SetXTitle("R for HF- jeta =-29; depth = 4 \b");
7764  HFnegativedirectionDigi4->Draw("Error");
7765  kcountHFnegativedirectionDigi4++;
7766  if (kcountHFnegativedirectionDigi4 > 13)
7767  break; // 4x6 = 24
7768  } //ccctest>0
7769 
7770  } // for i
7771  } //if(jeta-41< 0)
7772  } //for jeta
7774  c3x5->Update();
7775  c3x5->Print("RdigiNegativeDirectionhistD1PhiSymmetryDepth4HF.png");
7776  c3x5->Clear();
7777  // clean-up
7778  if (h2CeffHFnegativedirectionDigi4)
7779  delete h2CeffHFnegativedirectionDigi4;
7780 
7781  //======================================================================================================================
7782  //======================================================================================================================
7783  //======================================================================================================================
7784  // DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD:
7785 
7786  //cout<<" Start Vaiance: preparation *****" <<endl;
7787  TH2F *digiVariance1HF1 = (TH2F *)dir->FindObjectAny("h_amplitudechannel2_HF1");
7788  TH2F *digiVariance0HF1 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HF1");
7789  TH2F *digiVarianceHF1 = (TH2F *)digiVariance1HF1->Clone("digiVarianceHF1");
7790  digiVarianceHF1->Divide(digiVariance1HF1, digiVariance0HF1, 1, 1, "B");
7791  TH2F *digiVariance1HF2 = (TH2F *)dir->FindObjectAny("h_amplitudechannel2_HF2");
7792  TH2F *digiVariance0HF2 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HF2");
7793  TH2F *digiVarianceHF2 = (TH2F *)digiVariance1HF2->Clone("digiVarianceHF2");
7794  digiVarianceHF2->Divide(digiVariance1HF2, digiVariance0HF2, 1, 1, "B");
7795  TH2F *digiVariance1HF3 = (TH2F *)dir->FindObjectAny("h_amplitudechannel2_HF3");
7796  TH2F *digiVariance0HF3 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HF3");
7797  TH2F *digiVarianceHF3 = (TH2F *)digiVariance1HF3->Clone("digiVarianceHF3");
7798  digiVarianceHF3->Divide(digiVariance1HF3, digiVariance0HF3, 1, 1, "B");
7799  TH2F *digiVariance1HF4 = (TH2F *)dir->FindObjectAny("h_amplitudechannel2_HF4");
7800  TH2F *digiVariance0HF4 = (TH2F *)dir->FindObjectAny("h_amplitudechannel0_HF4");
7801  TH2F *digiVarianceHF4 = (TH2F *)digiVariance1HF4->Clone("digiVarianceHF4");
7802  digiVarianceHF4->Divide(digiVariance1HF4, digiVariance0HF4, 1, 1, "B");
7803  //cout<<" Vaiance: preparation DONE *****" <<endl;
7804  //====================================================================== put Vaiance=Dispersia = Sig**2=<R**2> - (<R>)**2 into massive digivarianceHF
7805  // = sum(R*R)/N - (sum(R)/N)**2
7806  for (int jeta = 0; jeta < njeta; jeta++) {
7807  //preparation for PHI normalization:
7808  double sumdigiHF0 = 0;
7809  int nsumdigiHF0 = 0;
7810  double sumdigiHF1 = 0;
7811  int nsumdigiHF1 = 0;
7812  double sumdigiHF2 = 0;
7813  int nsumdigiHF2 = 0;
7814  double sumdigiHF3 = 0;
7815  int nsumdigiHF3 = 0;
7816  for (int jphi = 0; jphi < njphi; jphi++) {
7817  digivarianceHF[0][jeta][jphi] = digiVarianceHF1->GetBinContent(jeta + 1, jphi + 1);
7818  digivarianceHF[1][jeta][jphi] = digiVarianceHF2->GetBinContent(jeta + 1, jphi + 1);
7819  digivarianceHF[2][jeta][jphi] = digiVarianceHF3->GetBinContent(jeta + 1, jphi + 1);
7820  digivarianceHF[3][jeta][jphi] = digiVarianceHF4->GetBinContent(jeta + 1, jphi + 1);
7821  if (digivarianceHF[0][jeta][jphi] > 0.) {
7822  sumdigiHF0 += digivarianceHF[0][jeta][jphi];
7823  ++nsumdigiHF0;
7824  }
7825  if (digivarianceHF[1][jeta][jphi] > 0.) {
7826  sumdigiHF1 += digivarianceHF[1][jeta][jphi];
7827  ++nsumdigiHF1;
7828  }
7829  if (digivarianceHF[2][jeta][jphi] > 0.) {
7830  sumdigiHF2 += digivarianceHF[2][jeta][jphi];
7831  ++nsumdigiHF2;
7832  }
7833  if (digivarianceHF[3][jeta][jphi] > 0.) {
7834  sumdigiHF3 += digivarianceHF[3][jeta][jphi];
7835  ++nsumdigiHF3;
7836  }
7837  } // phi
7838  // PHI normalization :
7839  for (int jphi = 0; jphi < njphi; jphi++) {
7840  if (digivarianceHF[0][jeta][jphi] > 0.)
7841  digivarianceHF[0][jeta][jphi] /= (sumdigiHF0 / nsumdigiHF0);
7842  if (digivarianceHF[1][jeta][jphi] > 0.)
7843  digivarianceHF[1][jeta][jphi] /= (sumdigiHF1 / nsumdigiHF1);
7844  if (digivarianceHF[2][jeta][jphi] > 0.)
7845  digivarianceHF[2][jeta][jphi] /= (sumdigiHF2 / nsumdigiHF2);
7846  if (digivarianceHF[3][jeta][jphi] > 0.)
7847  digivarianceHF[3][jeta][jphi] /= (sumdigiHF3 / nsumdigiHF3);
7848  } // phi
7849  // digivarianceHF (D) = sum(R*R)/N - (sum(R)/N)**2
7850  for (int jphi = 0; jphi < njphi; jphi++) {
7851  // cout<<"12 12 12 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
7852  digivarianceHF[0][jeta][jphi] -= adigiHF[0][jeta][jphi] * adigiHF[0][jeta][jphi];
7853  digivarianceHF[0][jeta][jphi] = fabs(digivarianceHF[0][jeta][jphi]);
7854  digivarianceHF[1][jeta][jphi] -= adigiHF[1][jeta][jphi] * adigiHF[1][jeta][jphi];
7855  digivarianceHF[1][jeta][jphi] = fabs(digivarianceHF[1][jeta][jphi]);
7856  digivarianceHF[2][jeta][jphi] -= adigiHF[2][jeta][jphi] * adigiHF[2][jeta][jphi];
7857  digivarianceHF[2][jeta][jphi] = fabs(digivarianceHF[2][jeta][jphi]);
7858  digivarianceHF[3][jeta][jphi] -= adigiHF[3][jeta][jphi] * adigiHF[3][jeta][jphi];
7859  digivarianceHF[3][jeta][jphi] = fabs(digivarianceHF[3][jeta][jphi]);
7860  }
7861  }
7862  //cout<<" Vaiance: DONE*****" <<endl;
7863  //------------------------ 2D-eta/phi-plot: D, averaged over depthfs
7864  //======================================================================
7865  //======================================================================
7866  //cout<<" R2D-eta/phi-plot: D, averaged over depthfs *****" <<endl;
7867  c1x1->Clear();
7869  c1x0->Divide(1, 1);
7870  c1x0->cd(1);
7871  TH2F *DefzDdigiHF42D = new TH2F("DefzDdigiHF42D", "", neta, -41., 41., nphi, 0., 72.);
7872  TH2F *DefzDdigiHF42D0 = new TH2F("DefzDdigiHF42D0", "", neta, -41., 41., nphi, 0., 72.);
7873  TH2F *DefzDdigiHF42DF = (TH2F *)DefzDdigiHF42D0->Clone("DefzDdigiHF42DF");
7874  for (int i = 0; i < ndepth; i++) {
7875  for (int jeta = 0; jeta < neta; jeta++) {
7876  for (int jphi = 0; jphi < nphi; jphi++) {
7877  double ccc1 = digivarianceHF[i][jeta][jphi];
7878  int k2plot = jeta - 41;
7879  int kkk = k2plot; //if(k2plot >0 kkk=k2plot+1; //-41 +41 !=0
7880  if (adigiHF[i][jeta][jphi] > 0.) {
7881  DefzDdigiHF42D->Fill(kkk, jphi, ccc1);
7882  DefzDdigiHF42D0->Fill(kkk, jphi, 1.);
7883  }
7884  }
7885  }
7886  }
7887  DefzDdigiHF42DF->Divide(DefzDdigiHF42D, DefzDdigiHF42D0, 1, 1, "B"); // average A
7888  // DefzDdigiHF1->Sumw2();
7889  gPad->SetGridy();
7890  gPad->SetGridx(); // gPad->SetLogz();
7891  DefzDdigiHF42DF->SetMarkerStyle(20);
7892  DefzDdigiHF42DF->SetMarkerSize(0.4);
7893  DefzDdigiHF42DF->GetZaxis()->SetLabelSize(0.08);
7894  DefzDdigiHF42DF->SetXTitle("<D>_depth #eta \b");
7895  DefzDdigiHF42DF->SetYTitle(" #phi \b");
7896  DefzDdigiHF42DF->SetZTitle("<D>_depth \b");
7897  DefzDdigiHF42DF->SetMarkerColor(2);
7898  DefzDdigiHF42DF->SetLineColor(
7899  0); // DefzDdigiHF42DF->SetMaximum(1.000); // DefzDdigiHF42DF->SetMinimum(1.0);
7900  DefzDdigiHF42DF->Draw("COLZ");
7902  c1x0->Update();
7903  c1x0->Print("DdigiGeneralD2PhiSymmetryHF.png");
7904  c1x0->Clear();
7905  // clean-up
7906  if (DefzDdigiHF42D)
7907  delete DefzDdigiHF42D;
7908  if (DefzDdigiHF42D0)
7909  delete DefzDdigiHF42D0;
7910  if (DefzDdigiHF42DF)
7911  delete DefzDdigiHF42DF;
7912  //====================================================================== 1D plot: D vs phi , averaged over depthfs & eta
7913  //======================================================================
7914  //cout<<" 1D plot: D vs phi , averaged over depthfs & eta *****" <<endl;
7915  c1x1->Clear();
7917  c1x1->Divide(1, 1);
7918  c1x1->cd(1);
7919  TH1F *DefzDdigiHF41D = new TH1F("DefzDdigiHF41D", "", nphi, 0., 72.);
7920  TH1F *DefzDdigiHF41D0 = new TH1F("DefzDdigiHF41D0", "", nphi, 0., 72.);
7921  TH1F *DefzDdigiHF41DF = (TH1F *)DefzDdigiHF41D0->Clone("DefzDdigiHF41DF");
7922 
7923  for (int jphi = 0; jphi < nphi; jphi++) {
7924  for (int jeta = 0; jeta < neta; jeta++) {
7925  for (int i = 0; i < ndepth; i++) {
7926  double ccc1 = digivarianceHF[i][jeta][jphi];
7927  if (adigiHF[i][jeta][jphi] > 0.) {
7928  DefzDdigiHF41D->Fill(jphi, ccc1);
7929  DefzDdigiHF41D0->Fill(jphi, 1.);
7930  }
7931  }
7932  }
7933  }
7934  // DefzDdigiHF41D->Sumw2();DefzDdigiHF41D0->Sumw2();
7935 
7936  DefzDdigiHF41DF->Divide(DefzDdigiHF41D, DefzDdigiHF41D0, 1, 1, "B"); // R averaged over depthfs & eta
7937  DefzDdigiHF41D0->Sumw2();
7938  // for (int jphi=1;jphi<73;jphi++) {DefzDdigiHF41DF->SetBinError(jphi,0.01);}
7939  gPad->SetGridy();
7940  gPad->SetGridx(); // gPad->SetLogz();
7941  DefzDdigiHF41DF->SetMarkerStyle(20);
7942  DefzDdigiHF41DF->SetMarkerSize(1.4);
7943  DefzDdigiHF41DF->GetZaxis()->SetLabelSize(0.08);
7944  DefzDdigiHF41DF->SetXTitle("#phi \b");
7945  DefzDdigiHF41DF->SetYTitle(" <D> \b");
7946  DefzDdigiHF41DF->SetZTitle("<D>_PHI - AllDepthfs \b");
7947  DefzDdigiHF41DF->SetMarkerColor(4);
7948  DefzDdigiHF41DF->SetLineColor(4); // DefzDdigiHF41DF->SetMinimum(0.8); DefzDdigiHF41DF->SetMinimum(-0.015);
7949  DefzDdigiHF41DF->Draw("Error");
7951  c1x1->Update();
7952  c1x1->Print("DdigiGeneralD1PhiSymmetryHF.png");
7953  c1x1->Clear();
7954  // clean-up
7955  if (DefzDdigiHF41D)
7956  delete DefzDdigiHF41D;
7957  if (DefzDdigiHF41D0)
7958  delete DefzDdigiHF41D0;
7959  if (DefzDdigiHF41DF)
7960  delete DefzDdigiHF41DF;
7961  //========================================================================================== 14
7962  //======================================================================
7963  //======================================================================1D plot: D vs phi , different eta, depth=1
7964  //cout<<" 1D plot: D vs phi , different eta, depth=1 *****" <<endl;
7965  c3x5->Clear();
7967  c3x5->Divide(3, 5);
7968  c3x5->cd(1);
7969  int kcountHFpositivedirectionDigiD1 = 1;
7970  TH1F *h2CeffHFpositivedirectionDigiD1 = new TH1F("h2CeffHFpositivedirectionDigiD1", "", nphi, 0., 72.);
7971 
7972  for (int jeta = 0; jeta < njeta; jeta++) {
7973  // positivedirectionDigiD:
7974  if (jeta - 41 >= 0) {
7975  // for (int i=0;i<ndepth;i++) {
7976  // depth=1
7977  for (int i = 0; i < 1; i++) {
7978  TH1F *HFpositivedirectionDigiD1 = (TH1F *)h2CeffHFpositivedirectionDigiD1->Clone("twod1");
7979 
7980  float ccctest = 0; // to avoid empty massive elements
7981  for (int jphi = 0; jphi < nphi; jphi++) {
7982  double ccc1 = digivarianceHF[i][jeta][jphi];
7983  if (adigiHF[i][jeta][jphi] > 0.) {
7984  HFpositivedirectionDigiD1->Fill(jphi, ccc1);
7985  ccctest = 1.; //HFpositivedirectionDigiD1->SetBinError(i,0.01);
7986  }
7987  } // for jphi
7988  if (ccctest > 0.) {
7989  //cout<<"1414 kcountHFpositivedirectionDigiD1 = "<<kcountHFpositivedirectionDigiD1 <<" jeta-41= "<< jeta-41 <<endl;
7990  c3x5->cd(kcountHFpositivedirectionDigiD1);
7991  HFpositivedirectionDigiD1->SetMarkerStyle(20);
7992  HFpositivedirectionDigiD1->SetMarkerSize(0.4);
7993  HFpositivedirectionDigiD1->GetYaxis()->SetLabelSize(0.04);
7994  HFpositivedirectionDigiD1->SetXTitle("HFpositivedirectionDigiD1 \b");
7995  HFpositivedirectionDigiD1->SetMarkerColor(2);
7996  HFpositivedirectionDigiD1->SetLineColor(0);
7997  gPad->SetGridy();
7998  gPad->SetGridx();
7999  // gPad->SetLogy();
8000  if (kcountHFpositivedirectionDigiD1 == 1)
8001  HFpositivedirectionDigiD1->SetXTitle("D for HF+ jeta = 28; depth = 1 \b");
8002  if (kcountHFpositivedirectionDigiD1 == 2)
8003  HFpositivedirectionDigiD1->SetXTitle("D for HF+ jeta = 29; depth = 1 \b");
8004  if (kcountHFpositivedirectionDigiD1 == 3)
8005  HFpositivedirectionDigiD1->SetXTitle("D for HF+ jeta = 30; depth = 1 \b");
8006  if (kcountHFpositivedirectionDigiD1 == 4)
8007  HFpositivedirectionDigiD1->SetXTitle("D for HF+ jeta = 31; depth = 1 \b");
8008  if (kcountHFpositivedirectionDigiD1 == 5)
8009  HFpositivedirectionDigiD1->SetXTitle("D for HF+ jeta = 32; depth = 1 \b");
8010  if (kcountHFpositivedirectionDigiD1 == 6)
8011  HFpositivedirectionDigiD1->SetXTitle("D for HF+ jeta = 33; depth = 1 \b");
8012  if (kcountHFpositivedirectionDigiD1 == 7)
8013  HFpositivedirectionDigiD1->SetXTitle("D for HF+ jeta = 34; depth = 1 \b");
8014  if (kcountHFpositivedirectionDigiD1 == 8)
8015  HFpositivedirectionDigiD1->SetXTitle("D for HF+ jeta = 35; depth = 1 \b");
8016  if (kcountHFpositivedirectionDigiD1 == 9)
8017  HFpositivedirectionDigiD1->SetXTitle("D for HF+ jeta = 36; depth = 1 \b");
8018  if (kcountHFpositivedirectionDigiD1 == 10)
8019  HFpositivedirectionDigiD1->SetXTitle("D for HF+ jeta = 37; depth = 1 \b");
8020  if (kcountHFpositivedirectionDigiD1 == 11)
8021  HFpositivedirectionDigiD1->SetXTitle("D for HF+ jeta = 38; depth = 1 \b");
8022  if (kcountHFpositivedirectionDigiD1 == 12)
8023  HFpositivedirectionDigiD1->SetXTitle("D for HF+ jeta = 39; depth = 1 \b");
8024  if (kcountHFpositivedirectionDigiD1 == 13)
8025  HFpositivedirectionDigiD1->SetXTitle("D for HF+ jeta = 40; depth = 1 \b");
8026  HFpositivedirectionDigiD1->Draw("Error");
8027  kcountHFpositivedirectionDigiD1++;
8028  if (kcountHFpositivedirectionDigiD1 > 13)
8029  break; // 4x6 = 24
8030  } //ccctest>0
8031 
8032  } // for i
8033  } //if(jeta-41 >= 0)
8034  } //for jeta
8036  c3x5->Update();
8037  c3x5->Print("DdigiPositiveDirectionhistD1PhiSymmetryDepth1HF.png");
8038  c3x5->Clear();
8039  // clean-up
8040  if (h2CeffHFpositivedirectionDigiD1)
8041  delete h2CeffHFpositivedirectionDigiD1;
8042  //========================================================================================== 15
8043  //======================================================================
8044  //======================================================================1D plot: D vs phi , different eta, depth=2
8045  //cout<<" 1D plot: D vs phi , different eta, depth=2 *****" <<endl;
8046  c3x5->Clear();
8047  c3x5->Divide(3, 5);
8048  c3x5->cd(1);
8049  int kcountHFpositivedirectionDigiD2 = 1;
8050  TH1F *h2CeffHFpositivedirectionDigiD2 = new TH1F("h2CeffHFpositivedirectionDigiD2", "", nphi, 0., 72.);
8051 
8052  for (int jeta = 0; jeta < njeta; jeta++) {
8053  // positivedirectionDigiD:
8054  if (jeta - 41 >= 0) {
8055  // for (int i=0;i<ndepth;i++) {
8056  // depth=2
8057  for (int i = 1; i < 2; i++) {
8058  TH1F *HFpositivedirectionDigiD2 = (TH1F *)h2CeffHFpositivedirectionDigiD2->Clone("twod1");
8059 
8060  float ccctest = 0; // to avoid empty massive elements
8061  for (int jphi = 0; jphi < nphi; jphi++) {
8062  double ccc1 = digivarianceHF[i][jeta][jphi];
8063  if (adigiHF[i][jeta][jphi] > 0.) {
8064  HFpositivedirectionDigiD2->Fill(jphi, ccc1);
8065  ccctest = 1.; //HFpositivedirectionDigiD2->SetBinError(i,0.01);
8066  }
8067  } // for jphi
8068  if (ccctest > 0.) {
8069  //cout<<"1515 kcountHFpositivedirectionDigiD2 = "<<kcountHFpositivedirectionDigiD2 <<" jeta-41= "<< jeta-41 <<endl;
8070  c3x5->cd(kcountHFpositivedirectionDigiD2);
8071  HFpositivedirectionDigiD2->SetMarkerStyle(20);
8072  HFpositivedirectionDigiD2->SetMarkerSize(0.4);
8073  HFpositivedirectionDigiD2->GetYaxis()->SetLabelSize(0.04);
8074  HFpositivedirectionDigiD2->SetXTitle("HFpositivedirectionDigiD2 \b");
8075  HFpositivedirectionDigiD2->SetMarkerColor(2);
8076  HFpositivedirectionDigiD2->SetLineColor(0);
8077  gPad->SetGridy();
8078  gPad->SetGridx();
8079  // gPad->SetLogy();
8080  if (kcountHFpositivedirectionDigiD2 == 1)
8081  HFpositivedirectionDigiD2->SetXTitle("D for HF+ jeta = 28; depth = 2 \b");
8082  if (kcountHFpositivedirectionDigiD2 == 2)
8083  HFpositivedirectionDigiD2->SetXTitle("D for HF+ jeta = 29; depth = 2 \b");
8084  if (kcountHFpositivedirectionDigiD2 == 3)
8085  HFpositivedirectionDigiD2->SetXTitle("D for HF+ jeta = 30; depth = 2 \b");
8086  if (kcountHFpositivedirectionDigiD2 == 4)
8087  HFpositivedirectionDigiD2->SetXTitle("D for HF+ jeta = 31; depth = 2 \b");
8088  if (kcountHFpositivedirectionDigiD2 == 5)
8089  HFpositivedirectionDigiD2->SetXTitle("D for HF+ jeta = 32; depth = 2 \b");
8090  if (kcountHFpositivedirectionDigiD2 == 6)
8091  HFpositivedirectionDigiD2->SetXTitle("D for HF+ jeta = 33; depth = 2 \b");
8092  if (kcountHFpositivedirectionDigiD2 == 7)
8093  HFpositivedirectionDigiD2->SetXTitle("D for HF+ jeta = 34; depth = 2 \b");
8094  if (kcountHFpositivedirectionDigiD2 == 8)
8095  HFpositivedirectionDigiD2->SetXTitle("D for HF+ jeta = 35; depth = 2 \b");
8096  if (kcountHFpositivedirectionDigiD2 == 9)
8097  HFpositivedirectionDigiD2->SetXTitle("D for HF+ jeta = 36; depth = 2 \b");
8098  if (kcountHFpositivedirectionDigiD2 == 10)
8099  HFpositivedirectionDigiD2->SetXTitle("D for HF+ jeta = 37; depth = 2 \b");
8100  if (kcountHFpositivedirectionDigiD2 == 11)
8101  HFpositivedirectionDigiD2->SetXTitle("D for HF+ jeta = 38; depth = 2 \b");
8102  if (kcountHFpositivedirectionDigiD2 == 12)
8103  HFpositivedirectionDigiD2->SetXTitle("D for HF+ jeta = 39; depth = 2 \b");
8104  if (kcountHFpositivedirectionDigiD2 == 13)
8105  HFpositivedirectionDigiD2->SetXTitle("D for HF+ jeta = 40; depth = 2 \b");
8106  HFpositivedirectionDigiD2->Draw("Error");
8107  kcountHFpositivedirectionDigiD2++;
8108  if (kcountHFpositivedirectionDigiD2 > 13)
8109  break; // 4x6 = 24
8110  } //ccctest>0
8111 
8112  } // for i
8113  } //if(jeta-41 >= 0)
8114  } //for jeta
8116  c3x5->Update();
8117  c3x5->Print("DdigiPositiveDirectionhistD1PhiSymmetryDepth2HF.png");
8118  c3x5->Clear();
8119  // clean-up
8120  if (h2CeffHFpositivedirectionDigiD2)
8121  delete h2CeffHFpositivedirectionDigiD2;
8122  //========================================================================================== 16
8123  //======================================================================
8124  //======================================================================1D plot: D vs phi , different eta, depth=3
8125  //cout<<" 1D plot: D vs phi , different eta, depth=3 *****" <<endl;
8126  c3x5->Clear();
8127  c3x5->Divide(3, 5);
8128  c3x5->cd(1);
8129  int kcountHFpositivedirectionDigiD3 = 1;
8130  TH1F *h2CeffHFpositivedirectionDigiD3 = new TH1F("h2CeffHFpositivedirectionDigiD3", "", nphi, 0., 72.);
8131 
8132  for (int jeta = 0; jeta < njeta; jeta++) {
8133  // positivedirectionDigiD:
8134  if (jeta - 41 >= 0) {
8135  // for (int i=0;i<ndepth;i++) {
8136  // depth=3
8137  for (int i = 2; i < 3; i++) {
8138  TH1F *HFpositivedirectionDigiD3 = (TH1F *)h2CeffHFpositivedirectionDigiD3->Clone("twod1");
8139 
8140  float ccctest = 0; // to avoid empty massive elements
8141  for (int jphi = 0; jphi < nphi; jphi++) {
8142  double ccc1 = digivarianceHF[i][jeta][jphi];
8143  if (adigiHF[i][jeta][jphi] > 0.) {
8144  HFpositivedirectionDigiD3->Fill(jphi, ccc1);
8145  ccctest = 1.; //HFpositivedirectionDigiD3->SetBinError(i,0.01);
8146  }
8147  } // for jphi
8148  if (ccctest > 0.) {
8149  //cout<<"1616 kcountHFpositivedirectionDigiD3 = "<<kcountHFpositivedirectionDigiD3 <<" jeta-41= "<< jeta-41 <<endl;
8150  c3x5->cd(kcountHFpositivedirectionDigiD3);
8151  HFpositivedirectionDigiD3->SetMarkerStyle(20);
8152  HFpositivedirectionDigiD3->SetMarkerSize(0.4);
8153  HFpositivedirectionDigiD3->GetYaxis()->SetLabelSize(0.04);
8154  HFpositivedirectionDigiD3->SetXTitle("HFpositivedirectionDigiD3 \b");
8155  HFpositivedirectionDigiD3->SetMarkerColor(2);
8156  HFpositivedirectionDigiD3->SetLineColor(0);
8157  gPad->SetGridy();
8158  gPad->SetGridx();
8159  // gPad->SetLogy();
8160  if (kcountHFpositivedirectionDigiD3 == 1)
8161  HFpositivedirectionDigiD3->SetXTitle("D for HF+ jeta = 28; depth = 3 \b");
8162  if (kcountHFpositivedirectionDigiD3 == 2)
8163  HFpositivedirectionDigiD3->SetXTitle("D for HF+ jeta = 29; depth = 3 \b");
8164  if (kcountHFpositivedirectionDigiD3 == 3)
8165  HFpositivedirectionDigiD3->SetXTitle("D for HF+ jeta = 30; depth = 3 \b");
8166  if (kcountHFpositivedirectionDigiD3 == 4)
8167  HFpositivedirectionDigiD3->SetXTitle("D for HF+ jeta = 31; depth = 3 \b");
8168  if (kcountHFpositivedirectionDigiD3 == 5)
8169  HFpositivedirectionDigiD3->SetXTitle("D for HF+ jeta = 32; depth = 3 \b");
8170  if (kcountHFpositivedirectionDigiD3 == 6)
8171  HFpositivedirectionDigiD3->SetXTitle("D for HF+ jeta = 33; depth = 3 \b");
8172  if (kcountHFpositivedirectionDigiD3 == 7)
8173  HFpositivedirectionDigiD3->SetXTitle("D for HF+ jeta = 34; depth = 3 \b");
8174  if (kcountHFpositivedirectionDigiD3 == 8)
8175  HFpositivedirectionDigiD3->SetXTitle("D for HF+ jeta = 35; depth = 3 \b");
8176  if (kcountHFpositivedirectionDigiD3 == 9)
8177  HFpositivedirectionDigiD3->SetXTitle("D for HF+ jeta = 36; depth = 3 \b");
8178  if (kcountHFpositivedirectionDigiD3 == 10)
8179  HFpositivedirectionDigiD3->SetXTitle("D for HF+ jeta = 37; depth = 3 \b");
8180  if (kcountHFpositivedirectionDigiD3 == 11)
8181  HFpositivedirectionDigiD3->SetXTitle("D for HF+ jeta = 38; depth = 3 \b");
8182  if (kcountHFpositivedirectionDigiD3 == 12)
8183  HFpositivedirectionDigiD3->SetXTitle("D for HF+ jeta = 39; depth = 3 \b");
8184  if (kcountHFpositivedirectionDigiD3 == 13)
8185  HFpositivedirectionDigiD3->SetXTitle("D for HF+ jeta = 40; depth = 3 \b");
8186  HFpositivedirectionDigiD3->Draw("Error");
8187  kcountHFpositivedirectionDigiD3++;
8188  if (kcountHFpositivedirectionDigiD3 > 13)
8189  break; // 4x6 = 24
8190  } //ccctest>0
8191 
8192  } // for i
8193  } //if(jeta-41 >= 0)
8194  } //for jeta
8196  c3x5->Update();
8197  c3x5->Print("DdigiPositiveDirectionhistD1PhiSymmetryDepth3HF.png");
8198  c3x5->Clear();
8199  // clean-up
8200  if (h2CeffHFpositivedirectionDigiD3)
8201  delete h2CeffHFpositivedirectionDigiD3;
8202  //========================================================================================== 17
8203  //======================================================================
8204  //======================================================================1D plot: D vs phi , different eta, depth=4
8205  //cout<<" 1D plot: D vs phi , different eta, depth=4 *****" <<endl;
8206  c3x5->Clear();
8207  c3x5->Divide(3, 5);
8208  c3x5->cd(1);
8209  int kcountHFpositivedirectionDigiD4 = 1;
8210  TH1F *h2CeffHFpositivedirectionDigiD4 = new TH1F("h2CeffHFpositivedirectionDigiD4", "", nphi, 0., 72.);
8211 
8212  for (int jeta = 0; jeta < njeta; jeta++) {
8213  // positivedirectionDigiD:
8214  if (jeta - 41 >= 0) {
8215  // for (int i=0;i<ndepth;i++) {
8216  // depth=4
8217  for (int i = 3; i < 4; i++) {
8218  TH1F *HFpositivedirectionDigiD4 = (TH1F *)h2CeffHFpositivedirectionDigiD4->Clone("twod1");
8219 
8220  float ccctest = 0; // to avoid empty massive elements
8221  for (int jphi = 0; jphi < nphi; jphi++) {
8222  double ccc1 = digivarianceHF[i][jeta][jphi];
8223  if (adigiHF[i][jeta][jphi] > 0.) {
8224  HFpositivedirectionDigiD4->Fill(jphi, ccc1);
8225  ccctest = 1.; //HFpositivedirectionDigiD4->SetBinError(i,0.01);
8226  }
8227  } // for jphi
8228  if (ccctest > 0.) {
8229  //cout<<"1717 kcountHFpositivedirectionDigiD4 = "<<kcountHFpositivedirectionDigiD4 <<" jeta-41= "<< jeta-41 <<endl;
8230  c3x5->cd(kcountHFpositivedirectionDigiD4);
8231  HFpositivedirectionDigiD4->SetMarkerStyle(20);
8232  HFpositivedirectionDigiD4->SetMarkerSize(0.4);
8233  HFpositivedirectionDigiD4->GetYaxis()->SetLabelSize(0.04);
8234  HFpositivedirectionDigiD4->SetXTitle("HFpositivedirectionDigiD4 \b");
8235  HFpositivedirectionDigiD4->SetMarkerColor(2);
8236  HFpositivedirectionDigiD4->SetLineColor(0);
8237  gPad->SetGridy();
8238  gPad->SetGridx();
8239  // gPad->SetLogy();
8240  if (kcountHFpositivedirectionDigiD4 == 1)
8241  HFpositivedirectionDigiD4->SetXTitle("D for HF+ jeta = 28; depth = 4 \b");
8242  if (kcountHFpositivedirectionDigiD4 == 2)
8243  HFpositivedirectionDigiD4->SetXTitle("D for HF+ jeta = 29; depth = 4 \b");
8244  if (kcountHFpositivedirectionDigiD4 == 3)
8245  HFpositivedirectionDigiD4->SetXTitle("D for HF+ jeta = 30; depth = 4 \b");
8246  if (kcountHFpositivedirectionDigiD4 == 4)
8247  HFpositivedirectionDigiD4->SetXTitle("D for HF+ jeta = 31; depth = 4 \b");
8248  if (kcountHFpositivedirectionDigiD4 == 5)
8249  HFpositivedirectionDigiD4->SetXTitle("D for HF+ jeta = 32; depth = 4 \b");
8250  if (kcountHFpositivedirectionDigiD4 == 6)
8251  HFpositivedirectionDigiD4->SetXTitle("D for HF+ jeta = 33; depth = 4 \b");
8252  if (kcountHFpositivedirectionDigiD4 == 7)
8253  HFpositivedirectionDigiD4->SetXTitle("D for HF+ jeta = 34; depth = 4 \b");
8254  if (kcountHFpositivedirectionDigiD4 == 8)
8255  HFpositivedirectionDigiD4->SetXTitle("D for HF+ jeta = 35; depth = 4 \b");
8256  if (kcountHFpositivedirectionDigiD4 == 9)
8257  HFpositivedirectionDigiD4->SetXTitle("D for HF+ jeta = 36; depth = 4 \b");
8258  if (kcountHFpositivedirectionDigiD4 == 10)
8259  HFpositivedirectionDigiD4->SetXTitle("D for HF+ jeta = 37; depth = 4 \b");
8260  if (kcountHFpositivedirectionDigiD4 == 11)
8261  HFpositivedirectionDigiD4->SetXTitle("D for HF+ jeta = 38; depth = 4 \b");
8262  if (kcountHFpositivedirectionDigiD4 == 12)
8263  HFpositivedirectionDigiD4->SetXTitle("D for HF+ jeta = 39; depth = 4 \b");
8264  if (kcountHFpositivedirectionDigiD4 == 13)
8265  HFpositivedirectionDigiD4->SetXTitle("D for HF+ jeta = 40; depth = 4 \b");
8266  HFpositivedirectionDigiD4->Draw("Error");
8267  kcountHFpositivedirectionDigiD4++;
8268  if (kcountHFpositivedirectionDigiD4 > 13)
8269  break; // 4x6 = 24
8270  } //ccctest>0
8271 
8272  } // for i
8273  } //if(jeta-41 >= 0)
8274  } //for jeta
8276  c3x5->Update();
8277  c3x5->Print("DdigiPositiveDirectionhistD1PhiSymmetryDepth4HF.png");
8278  c3x5->Clear();
8279  // clean-up
8280  if (h2CeffHFpositivedirectionDigiD4)
8281  delete h2CeffHFpositivedirectionDigiD4;
8282 
8283  //========================================================================================== 22222214
8284  //======================================================================
8285  //======================================================================1D plot: D vs phi , different eta, depth=1
8286  //cout<<" 1D plot: D vs phi , different eta, depth=1 *****" <<endl;
8287  c3x5->Clear();
8289  c3x5->Divide(3, 5);
8290  c3x5->cd(1);
8291  int kcountHFnegativedirectionDigiD1 = 1;
8292  TH1F *h2CeffHFnegativedirectionDigiD1 = new TH1F("h2CeffHFnegativedirectionDigiD1", "", nphi, 0., 72.);
8293 
8294  for (int jeta = 0; jeta < njeta; jeta++) {
8295  // negativedirectionDigiD:
8296  if (jeta - 41 < 0) {
8297  // for (int i=0;i<ndepth;i++) {
8298  // depth=1
8299  for (int i = 0; i < 1; i++) {
8300  TH1F *HFnegativedirectionDigiD1 = (TH1F *)h2CeffHFnegativedirectionDigiD1->Clone("twod1");
8301 
8302  float ccctest = 0; // to avoid empty massive elements
8303  for (int jphi = 0; jphi < nphi; jphi++) {
8304  double ccc1 = digivarianceHF[i][jeta][jphi];
8305  if (adigiHF[i][jeta][jphi] > 0.) {
8306  HFnegativedirectionDigiD1->Fill(jphi, ccc1);
8307  ccctest = 1.; //HFnegativedirectionDigiD1->SetBinError(i,0.01);
8308  }
8309  } // for jphi
8310  if (ccctest > 0.) {
8311  //cout<<"1414 kcountHFnegativedirectionDigiD1 = "<<kcountHFnegativedirectionDigiD1 <<" jeta-41= "<< jeta-41 <<endl;
8312  c3x5->cd(kcountHFnegativedirectionDigiD1);
8313  HFnegativedirectionDigiD1->SetMarkerStyle(20);
8314  HFnegativedirectionDigiD1->SetMarkerSize(0.4);
8315  HFnegativedirectionDigiD1->GetYaxis()->SetLabelSize(0.04);
8316  HFnegativedirectionDigiD1->SetXTitle("HFnegativedirectionDigiD1 \b");
8317  HFnegativedirectionDigiD1->SetMarkerColor(2);
8318  HFnegativedirectionDigiD1->SetLineColor(0);
8319  gPad->SetGridy();
8320  gPad->SetGridx();
8321  // gPad->SetLogy();
8322  if (kcountHFnegativedirectionDigiD1 == 1)
8323  HFnegativedirectionDigiD1->SetXTitle("D for HF- jeta =-41; depth = 1 \b");
8324  if (kcountHFnegativedirectionDigiD1 == 2)
8325  HFnegativedirectionDigiD1->SetXTitle("D for HF- jeta =-40; depth = 1 \b");
8326  if (kcountHFnegativedirectionDigiD1 == 3)
8327  HFnegativedirectionDigiD1->SetXTitle("D for HF- jeta =-39; depth = 1 \b");
8328  if (kcountHFnegativedirectionDigiD1 == 4)
8329  HFnegativedirectionDigiD1->SetXTitle("D for HF- jeta =-38; depth = 1 \b");
8330  if (kcountHFnegativedirectionDigiD1 == 5)
8331  HFnegativedirectionDigiD1->SetXTitle("D for HF- jeta =-37; depth = 1 \b");
8332  if (kcountHFnegativedirectionDigiD1 == 6)
8333  HFnegativedirectionDigiD1->SetXTitle("D for HF- jeta =-36; depth = 1 \b");
8334  if (kcountHFnegativedirectionDigiD1 == 7)
8335  HFnegativedirectionDigiD1->SetXTitle("D for HF- jeta =-35; depth = 1 \b");
8336  if (kcountHFnegativedirectionDigiD1 == 8)
8337  HFnegativedirectionDigiD1->SetXTitle("D for HF- jeta =-34; depth = 1 \b");
8338  if (kcountHFnegativedirectionDigiD1 == 9)
8339  HFnegativedirectionDigiD1->SetXTitle("D for HF- jeta =-33; depth = 1 \b");
8340  if (kcountHFnegativedirectionDigiD1 == 10)
8341  HFnegativedirectionDigiD1->SetXTitle("D for HF- jeta =-32; depth = 1 \b");
8342  if (kcountHFnegativedirectionDigiD1 == 11)
8343  HFnegativedirectionDigiD1->SetXTitle("D for HF- jeta =-31; depth = 1 \b");
8344  if (kcountHFnegativedirectionDigiD1 == 12)
8345  HFnegativedirectionDigiD1->SetXTitle("D for HF- jeta =-30; depth = 1 \b");
8346  if (kcountHFnegativedirectionDigiD1 == 13)
8347  HFnegativedirectionDigiD1->SetXTitle("D for HF- jeta =-29; depth = 1 \b");
8348  HFnegativedirectionDigiD1->Draw("Error");
8349  kcountHFnegativedirectionDigiD1++;
8350  if (kcountHFnegativedirectionDigiD1 > 13)
8351  break; // 4x6 = 24
8352  } //ccctest>0
8353 
8354  } // for i
8355  } //if(jeta-41< 0)
8356  } //for jeta
8358  c3x5->Update();
8359  c3x5->Print("DdigiNegativeDirectionhistD1PhiSymmetryDepth1HF.png");
8360  c3x5->Clear();
8361  // clean-up
8362  if (h2CeffHFnegativedirectionDigiD1)
8363  delete h2CeffHFnegativedirectionDigiD1;
8364  //========================================================================================== 22222215
8365  //======================================================================
8366  //======================================================================1D plot: D vs phi , different eta, depth=2
8367  //cout<<" 1D plot: D vs phi , different eta, depth=2 *****" <<endl;
8368  c3x5->Clear();
8369  c3x5->Divide(3, 5);
8370  c3x5->cd(1);
8371  int kcountHFnegativedirectionDigiD2 = 1;
8372  TH1F *h2CeffHFnegativedirectionDigiD2 = new TH1F("h2CeffHFnegativedirectionDigiD2", "", nphi, 0., 72.);
8373 
8374  for (int jeta = 0; jeta < njeta; jeta++) {
8375  // negativedirectionDigiD:
8376  if (jeta - 41 < 0) {
8377  // for (int i=0;i<ndepth;i++) {
8378  // depth=2
8379  for (int i = 1; i < 2; i++) {
8380  TH1F *HFnegativedirectionDigiD2 = (TH1F *)h2CeffHFnegativedirectionDigiD2->Clone("twod1");
8381 
8382  float ccctest = 0; // to avoid empty massive elements
8383  for (int jphi = 0; jphi < nphi; jphi++) {
8384  double ccc1 = digivarianceHF[i][jeta][jphi];
8385  if (adigiHF[i][jeta][jphi] > 0.) {
8386  HFnegativedirectionDigiD2->Fill(jphi, ccc1);
8387  ccctest = 1.; //HFnegativedirectionDigiD2->SetBinError(i,0.01);
8388  }
8389  } // for jphi
8390  if (ccctest > 0.) {
8391  //cout<<"1515 kcountHFnegativedirectionDigiD2 = "<<kcountHFnegativedirectionDigiD2 <<" jeta-41= "<< jeta-41 <<endl;
8392  c3x5->cd(kcountHFnegativedirectionDigiD2);
8393  HFnegativedirectionDigiD2->SetMarkerStyle(20);
8394  HFnegativedirectionDigiD2->SetMarkerSize(0.4);
8395  HFnegativedirectionDigiD2->GetYaxis()->SetLabelSize(0.04);
8396  HFnegativedirectionDigiD2->SetXTitle("HFnegativedirectionDigiD2 \b");
8397  HFnegativedirectionDigiD2->SetMarkerColor(2);
8398  HFnegativedirectionDigiD2->SetLineColor(0);
8399  gPad->SetGridy();
8400  gPad->SetGridx();
8401  // gPad->SetLogy();
8402  if (kcountHFnegativedirectionDigiD2 == 1)
8403  HFnegativedirectionDigiD2->SetXTitle("D for HF- jeta =-41; depth = 2 \b");
8404  if (kcountHFnegativedirectionDigiD2 == 2)
8405  HFnegativedirectionDigiD2->SetXTitle("D for HF- jeta =-40; depth = 2 \b");
8406  if (kcountHFnegativedirectionDigiD2 == 3)
8407  HFnegativedirectionDigiD2->SetXTitle("D for HF- jeta =-39; depth = 2 \b");
8408  if (kcountHFnegativedirectionDigiD2 == 4)
8409  HFnegativedirectionDigiD2->SetXTitle("D for HF- jeta =-38; depth = 2 \b");
8410  if (kcountHFnegativedirectionDigiD2 == 5)
8411  HFnegativedirectionDigiD2->SetXTitle("D for HF- jeta =-37; depth = 2 \b");
8412  if (kcountHFnegativedirectionDigiD2 == 6)
8413  HFnegativedirectionDigiD2->SetXTitle("D for HF- jeta =-36; depth = 2 \b");
8414  if (kcountHFnegativedirectionDigiD2 == 7)
8415  HFnegativedirectionDigiD2->SetXTitle("D for HF- jeta =-35; depth = 2 \b");
8416  if (kcountHFnegativedirectionDigiD2 == 8)
8417  HFnegativedirectionDigiD2->SetXTitle("D for HF- jeta =-34; depth = 2 \b");
8418  if (kcountHFnegativedirectionDigiD2 == 9)
8419  HFnegativedirectionDigiD2->SetXTitle("D for HF- jeta =-33; depth = 2 \b");
8420  if (kcountHFnegativedirectionDigiD2 == 10)
8421  HFnegativedirectionDigiD2->SetXTitle("D for HF- jeta =-32; depth = 2 \b");
8422  if (kcountHFnegativedirectionDigiD2 == 11)
8423  HFnegativedirectionDigiD2->SetXTitle("D for HF- jeta =-31; depth = 2 \b");
8424  if (kcountHFnegativedirectionDigiD2 == 12)
8425  HFnegativedirectionDigiD2->SetXTitle("D for HF- jeta =-30; depth = 2 \b");
8426  if (kcountHFnegativedirectionDigiD2 == 13)
8427  HFnegativedirectionDigiD2->SetXTitle("D for HF- jeta =-29; depth = 2 \b");
8428  HFnegativedirectionDigiD2->Draw("Error");
8429  kcountHFnegativedirectionDigiD2++;
8430  if (kcountHFnegativedirectionDigiD2 > 13)
8431  break; // 4x6 = 24
8432  } //ccctest>0
8433 
8434  } // for i
8435  } //if(jeta-41< 0)
8436  } //for jeta
8438  c3x5->Update();
8439  c3x5->Print("DdigiNegativeDirectionhistD1PhiSymmetryDepth2HF.png");
8440  c3x5->Clear();
8441  // clean-up
8442  if (h2CeffHFnegativedirectionDigiD2)
8443  delete h2CeffHFnegativedirectionDigiD2;
8444  //========================================================================================== 22222216
8445  //======================================================================
8446  //======================================================================1D plot: D vs phi , different eta, depth=3
8447  //cout<<" 1D plot: D vs phi , different eta, depth=3 *****" <<endl;
8448  c3x5->Clear();
8449  c3x5->Divide(3, 5);
8450  c3x5->cd(1);
8451  int kcountHFnegativedirectionDigiD3 = 1;
8452  TH1F *h2CeffHFnegativedirectionDigiD3 = new TH1F("h2CeffHFnegativedirectionDigiD3", "", nphi, 0., 72.);
8453 
8454  for (int jeta = 0; jeta < njeta; jeta++) {
8455  // negativedirectionDigiD:
8456  if (jeta - 41 < 0) {
8457  // for (int i=0;i<ndepth;i++) {
8458  // depth=3
8459  for (int i = 2; i < 3; i++) {
8460  TH1F *HFnegativedirectionDigiD3 = (TH1F *)h2CeffHFnegativedirectionDigiD3->Clone("twod1");
8461 
8462  float ccctest = 0; // to avoid empty massive elements
8463  for (int jphi = 0; jphi < nphi; jphi++) {
8464  double ccc1 = digivarianceHF[i][jeta][jphi];
8465  if (adigiHF[i][jeta][jphi] > 0.) {
8466  HFnegativedirectionDigiD3->Fill(jphi, ccc1);
8467  ccctest = 1.; //HFnegativedirectionDigiD3->SetBinError(i,0.01);
8468  }
8469  } // for jphi
8470  if (ccctest > 0.) {
8471  //cout<<"1616 kcountHFnegativedirectionDigiD3 = "<<kcountHFnegativedirectionDigiD3 <<" jeta-41= "<< jeta-41 <<endl;
8472  c3x5->cd(kcountHFnegativedirectionDigiD3);
8473  HFnegativedirectionDigiD3->SetMarkerStyle(20);
8474  HFnegativedirectionDigiD3->SetMarkerSize(0.4);
8475  HFnegativedirectionDigiD3->GetYaxis()->SetLabelSize(0.04);
8476  HFnegativedirectionDigiD3->SetXTitle("HFnegativedirectionDigiD3 \b");
8477  HFnegativedirectionDigiD3->SetMarkerColor(2);
8478  HFnegativedirectionDigiD3->SetLineColor(0);
8479  gPad->SetGridy();
8480  gPad->SetGridx();
8481  // gPad->SetLogy();
8482  if (kcountHFnegativedirectionDigiD3 == 1)
8483  HFnegativedirectionDigiD3->SetXTitle("D for HF- jeta =-41; depth = 3 \b");
8484  if (kcountHFnegativedirectionDigiD3 == 2)
8485  HFnegativedirectionDigiD3->SetXTitle("D for HF- jeta =-40; depth = 3 \b");
8486  if (kcountHFnegativedirectionDigiD3 == 3)
8487  HFnegativedirectionDigiD3->SetXTitle("D for HF- jeta =-39; depth = 3 \b");
8488  if (kcountHFnegativedirectionDigiD3 == 4)
8489  HFnegativedirectionDigiD3->SetXTitle("D for HF- jeta =-38; depth = 3 \b");
8490  if (kcountHFnegativedirectionDigiD3 == 5)
8491  HFnegativedirectionDigiD3->SetXTitle("D for HF- jeta =-37; depth = 3 \b");
8492  if (kcountHFnegativedirectionDigiD3 == 6)
8493  HFnegativedirectionDigiD3->SetXTitle("D for HF- jeta =-36; depth = 3 \b");
8494  if (kcountHFnegativedirectionDigiD3 == 7)
8495  HFnegativedirectionDigiD3->SetXTitle("D for HF- jeta =-35; depth = 3 \b");
8496  if (kcountHFnegativedirectionDigiD3 == 8)
8497  HFnegativedirectionDigiD3->SetXTitle("D for HF- jeta =-34; depth = 3 \b");
8498  if (kcountHFnegativedirectionDigiD3 == 9)
8499  HFnegativedirectionDigiD3->SetXTitle("D for HF- jeta =-33; depth = 3 \b");
8500  if (kcountHFnegativedirectionDigiD3 == 10)
8501  HFnegativedirectionDigiD3->SetXTitle("D for HF- jeta =-32; depth = 3 \b");
8502  if (kcountHFnegativedirectionDigiD3 == 11)
8503  HFnegativedirectionDigiD3->SetXTitle("D for HF- jeta =-31; depth = 3 \b");
8504  if (kcountHFnegativedirectionDigiD3 == 12)
8505  HFnegativedirectionDigiD3->SetXTitle("D for HF- jeta =-30; depth = 3 \b");
8506  if (kcountHFnegativedirectionDigiD3 == 13)
8507  HFnegativedirectionDigiD3->SetXTitle("D for HF- jeta =-29; depth = 3 \b");
8508  HFnegativedirectionDigiD3->Draw("Error");
8509  kcountHFnegativedirectionDigiD3++;
8510  if (kcountHFnegativedirectionDigiD3 > 13)
8511  break; // 4x6 = 24
8512  } //ccctest>0
8513 
8514  } // for i
8515  } //if(jeta-41< 0)
8516  } //for jeta
8518  c3x5->Update();
8519  c3x5->Print("DdigiNegativeDirectionhistD1PhiSymmetryDepth3HF.png");
8520  c3x5->Clear();
8521  // clean-up
8522  if (h2CeffHFnegativedirectionDigiD3)
8523  delete h2CeffHFnegativedirectionDigiD3;
8524  //========================================================================================== 22222217
8525  //======================================================================
8526  //======================================================================1D plot: D vs phi , different eta, depth=4
8527  //cout<<" 1D plot: D vs phi , different eta, depth=4 *****" <<endl;
8528  c3x5->Clear();
8529  c3x5->Divide(3, 5);
8530  c3x5->cd(1);
8531  int kcountHFnegativedirectionDigiD4 = 1;
8532  TH1F *h2CeffHFnegativedirectionDigiD4 = new TH1F("h2CeffHFnegativedirectionDigiD4", "", nphi, 0., 72.);
8533 
8534  for (int jeta = 0; jeta < njeta; jeta++) {
8535  // negativedirectionDigiD:
8536  if (jeta - 41 < 0) {
8537  // for (int i=0;i<ndepth;i++) {
8538  // depth=4
8539  for (int i = 3; i < 4; i++) {
8540  TH1F *HFnegativedirectionDigiD4 = (TH1F *)h2CeffHFnegativedirectionDigiD4->Clone("twod1");
8541 
8542  float ccctest = 0; // to avoid empty massive elements
8543  for (int jphi = 0; jphi < nphi; jphi++) {
8544  double ccc1 = digivarianceHF[i][jeta][jphi];
8545  if (adigiHF[i][jeta][jphi] > 0.) {
8546  HFnegativedirectionDigiD4->Fill(jphi, ccc1);
8547  ccctest = 1.; //HFnegativedirectionDigiD4->SetBinError(i,0.01);
8548  }
8549  } // for jphi
8550  if (ccctest > 0.) {
8551  //cout<<"1717 kcountHFnegativedirectionDigiD4 = "<<kcountHFnegativedirectionDigiD4 <<" jeta-41= "<< jeta-41 <<endl;
8552  c3x5->cd(kcountHFnegativedirectionDigiD4);
8553  HFnegativedirectionDigiD4->SetMarkerStyle(20);
8554  HFnegativedirectionDigiD4->SetMarkerSize(0.4);
8555  HFnegativedirectionDigiD4->GetYaxis()->SetLabelSize(0.04);
8556  HFnegativedirectionDigiD4->SetXTitle("HFnegativedirectionDigiD4 \b");
8557  HFnegativedirectionDigiD4->SetMarkerColor(2);
8558  HFnegativedirectionDigiD4->SetLineColor(0);
8559  gPad->SetGridy();
8560  gPad->SetGridx();
8561  // gPad->SetLogy();
8562  if (kcountHFnegativedirectionDigiD4 == 1)
8563  HFnegativedirectionDigiD4->SetXTitle("D for HF- jeta =-41; depth = 4 \b");
8564  if (kcountHFnegativedirectionDigiD4 == 2)
8565  HFnegativedirectionDigiD4->SetXTitle("D for HF- jeta =-40; depth = 4 \b");
8566  if (kcountHFnegativedirectionDigiD4 == 3)
8567  HFnegativedirectionDigiD4->SetXTitle("D for HF- jeta =-39; depth = 4 \b");
8568  if (kcountHFnegativedirectionDigiD4 == 4)
8569  HFnegativedirectionDigiD4->SetXTitle("D for HF- jeta =-38; depth = 4 \b");
8570  if (kcountHFnegativedirectionDigiD4 == 5)
8571  HFnegativedirectionDigiD4->SetXTitle("D for HF- jeta =-37; depth = 4 \b");
8572  if (kcountHFnegativedirectionDigiD4 == 6)
8573  HFnegativedirectionDigiD4->SetXTitle("D for HF- jeta =-36; depth = 4 \b");
8574  if (kcountHFnegativedirectionDigiD4 == 7)
8575  HFnegativedirectionDigiD4->SetXTitle("D for HF- jeta =-35; depth = 4 \b");
8576  if (kcountHFnegativedirectionDigiD4 == 8)
8577  HFnegativedirectionDigiD4->SetXTitle("D for HF- jeta =-34; depth = 4 \b");
8578  if (kcountHFnegativedirectionDigiD4 == 9)
8579  HFnegativedirectionDigiD4->SetXTitle("D for HF- jeta =-33; depth = 4 \b");
8580  if (kcountHFnegativedirectionDigiD4 == 10)
8581  HFnegativedirectionDigiD4->SetXTitle("D for HF- jeta =-32; depth = 4 \b");
8582  if (kcountHFnegativedirectionDigiD4 == 11)
8583  HFnegativedirectionDigiD4->SetXTitle("D for HF- jeta =-31; depth = 4 \b");
8584  if (kcountHFnegativedirectionDigiD4 == 12)
8585  HFnegativedirectionDigiD4->SetXTitle("D for HF- jeta =-30; depth = 4 \b");
8586  if (kcountHFnegativedirectionDigiD4 == 13)
8587  HFnegativedirectionDigiD4->SetXTitle("D for HF- jeta =-29; depth = 4 \b");
8588  HFnegativedirectionDigiD4->Draw("Error");
8589  kcountHFnegativedirectionDigiD4++;
8590  if (kcountHFnegativedirectionDigiD4 > 13)
8591  break; // 4x6 = 24
8592  } //ccctest>0
8593 
8594  } // for i
8595  } //if(jeta-41< 0)
8596  } //for jeta
8598  c3x5->Update();
8599  c3x5->Print("DdigiNegativeDirectionhistD1PhiSymmetryDepth4HF.png");
8600  c3x5->Clear();
8601  // clean-up
8602  if (h2CeffHFnegativedirectionDigiD4)
8603  delete h2CeffHFnegativedirectionDigiD4;
8604 
8605  //===================================================================== END of Digi HF for phi-symmetry
8606  //===================================================================== END of Digi HF for phi-symmetry
8607  //===================================================================== END of Digi HF for phi-symmetry
8608 
8609  //============================================================================================================ END of Digi for phi-symmetry
8610  //============================================================================================================ END of Digi for phi-symmetry
8611  //============================================================================================================ END of Digi for phi-symmetry
8612 
8613  //============================================================================================================ END of Digi for phi-symmetry
8614  //============================================================================================================ END of Digi for phi-symmetry
8615  //============================================================================================================ END of Digi for phi-symmetry
8616  //============================================================================================================ END of Digi for phi-symmetry
8617  //============================================================================================================ END of Digi for phi-symmetry
8618  //============================================================================================================ END of Digi for phi-symmetry
8619  //============================================================================================================ END of Digi for phi-symmetry
8620  //============================================================================================================ END of Digi for phi-symmetry
8621  //============================================================================================================ END of Digi for phi-symmetry
8622 
8623  // END of Digi Digi Digi Digi Digi ENDDigi Digi Digi Digi Digi ENDDigi Digi Digi Digi ENDDigi Digi Digi Digi Digi Digi Digi ENDDigi Digi Digi Digi Digi Digi Digi Digi Digi Digi ENDDigi END
8624 
8628 
8632  // int k_max[5]={0,4,7,4,4}; // maximum depth for each subdet
8633  //ndepth = k_max[5];
8634  ndepth = 4;
8635  double arecosignalHB[ndepth][njeta][njphi];
8636  double recosignalvarianceHB[ndepth][njeta][njphi];
8637  // RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR: Recosignal HB recSignalEnergy
8638  TH2F *recSignalEnergy1HB1 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy1_HB1");
8639  TH2F *recSignalEnergy0HB1 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HB1");
8640  TH2F *recSignalEnergyHB1 = (TH2F *)recSignalEnergy1HB1->Clone("recSignalEnergyHB1");
8641  recSignalEnergyHB1->Divide(recSignalEnergy1HB1, recSignalEnergy0HB1, 1, 1, "B");
8642  TH2F *recSignalEnergy1HB2 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy1_HB2");
8643  TH2F *recSignalEnergy0HB2 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HB2");
8644  TH2F *recSignalEnergyHB2 = (TH2F *)recSignalEnergy1HB2->Clone("recSignalEnergyHB2");
8645  recSignalEnergyHB2->Divide(recSignalEnergy1HB2, recSignalEnergy0HB2, 1, 1, "B");
8646  TH2F *recSignalEnergy1HB3 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy1_HB3");
8647  TH2F *recSignalEnergy0HB3 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HB3");
8648  TH2F *recSignalEnergyHB3 = (TH2F *)recSignalEnergy1HB3->Clone("recSignalEnergyHB3");
8649  recSignalEnergyHB3->Divide(recSignalEnergy1HB3, recSignalEnergy0HB3, 1, 1, "B");
8650  TH2F *recSignalEnergy1HB4 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy1_HB4");
8651  TH2F *recSignalEnergy0HB4 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HB4");
8652  TH2F *recSignalEnergyHB4 = (TH2F *)recSignalEnergy1HB4->Clone("recSignalEnergyHB4");
8653  recSignalEnergyHB4->Divide(recSignalEnergy1HB4, recSignalEnergy0HB4, 1, 1, "B");
8654  for (int jeta = 0; jeta < njeta; jeta++) {
8655  //====================================================================== PHI normalization & put R into massive arecosignalHB
8656  //preparation for PHI normalization:
8657  double sumrecosignalHB0 = 0;
8658  int nsumrecosignalHB0 = 0;
8659  double sumrecosignalHB1 = 0;
8660  int nsumrecosignalHB1 = 0;
8661  double sumrecosignalHB2 = 0;
8662  int nsumrecosignalHB2 = 0;
8663  double sumrecosignalHB3 = 0;
8664  int nsumrecosignalHB3 = 0;
8665  for (int jphi = 0; jphi < njphi; jphi++) {
8666  arecosignalHB[0][jeta][jphi] = recSignalEnergyHB1->GetBinContent(jeta + 1, jphi + 1);
8667  arecosignalHB[1][jeta][jphi] = recSignalEnergyHB2->GetBinContent(jeta + 1, jphi + 1);
8668  arecosignalHB[2][jeta][jphi] = recSignalEnergyHB3->GetBinContent(jeta + 1, jphi + 1);
8669  arecosignalHB[3][jeta][jphi] = recSignalEnergyHB4->GetBinContent(jeta + 1, jphi + 1);
8670  if (arecosignalHB[0][jeta][jphi] > 0.) {
8671  sumrecosignalHB0 += arecosignalHB[0][jeta][jphi];
8672  ++nsumrecosignalHB0;
8673  }
8674  if (arecosignalHB[1][jeta][jphi] > 0.) {
8675  sumrecosignalHB1 += arecosignalHB[1][jeta][jphi];
8676  ++nsumrecosignalHB1;
8677  }
8678  if (arecosignalHB[2][jeta][jphi] > 0.) {
8679  sumrecosignalHB2 += arecosignalHB[2][jeta][jphi];
8680  ++nsumrecosignalHB2;
8681  }
8682  if (arecosignalHB[3][jeta][jphi] > 0.) {
8683  sumrecosignalHB3 += arecosignalHB[3][jeta][jphi];
8684  ++nsumrecosignalHB3;
8685  }
8686  } // phi
8687  // PHI normalization:
8688  for (int jphi = 0; jphi < njphi; jphi++) {
8689  if (arecosignalHB[0][jeta][jphi] > 0.)
8690  arecosignalHB[0][jeta][jphi] /= (sumrecosignalHB0 / nsumrecosignalHB0);
8691  if (arecosignalHB[1][jeta][jphi] > 0.)
8692  arecosignalHB[1][jeta][jphi] /= (sumrecosignalHB1 / nsumrecosignalHB1);
8693  if (arecosignalHB[2][jeta][jphi] > 0.)
8694  arecosignalHB[2][jeta][jphi] /= (sumrecosignalHB2 / nsumrecosignalHB2);
8695  if (arecosignalHB[3][jeta][jphi] > 0.)
8696  arecosignalHB[3][jeta][jphi] /= (sumrecosignalHB3 / nsumrecosignalHB3);
8697  } // phi
8698  } //eta
8699  //------------------------ 2D-eta/phi-plot: R, averaged over depthfs
8700  //======================================================================
8701  //======================================================================
8702  //cout<<" R2D-eta/phi-plot: R, averaged over depthfs *****" <<endl;
8703  c2x1->Clear();
8705  c2x1->Divide(2, 1);
8706  c2x1->cd(1);
8707  TH2F *GefzRrecosignalHB42D = new TH2F("GefzRrecosignalHB42D", "", neta, -41., 41., nphi, 0., 72.);
8708  TH2F *GefzRrecosignalHB42D0 = new TH2F("GefzRrecosignalHB42D0", "", neta, -41., 41., nphi, 0., 72.);
8709  TH2F *GefzRrecosignalHB42DF = (TH2F *)GefzRrecosignalHB42D0->Clone("GefzRrecosignalHB42DF");
8710  for (int i = 0; i < ndepth; i++) {
8711  for (int jeta = 0; jeta < neta; jeta++) {
8712  for (int jphi = 0; jphi < nphi; jphi++) {
8713  double ccc1 = arecosignalHB[i][jeta][jphi];
8714  int k2plot = jeta - 41;
8715  int kkk = k2plot; //if(k2plot >0 ) kkk=k2plot+1; //-41 +41 !=0
8716  if (ccc1 != 0.) {
8717  GefzRrecosignalHB42D->Fill(kkk, jphi, ccc1);
8718  GefzRrecosignalHB42D0->Fill(kkk, jphi, 1.);
8719  }
8720  }
8721  }
8722  }
8723  GefzRrecosignalHB42DF->Divide(GefzRrecosignalHB42D, GefzRrecosignalHB42D0, 1, 1, "B"); // average A
8724  gPad->SetGridy();
8725  gPad->SetGridx(); // gPad->SetLogz();
8726  GefzRrecosignalHB42DF->SetXTitle("<R>_depth #eta \b");
8727  GefzRrecosignalHB42DF->SetYTitle(" #phi \b");
8728  GefzRrecosignalHB42DF->Draw("COLZ");
8729 
8730  c2x1->cd(2);
8731  TH1F *energyhitSignal_HB = (TH1F *)dir->FindObjectAny("h_energyhitSignal_HB");
8732  energyhitSignal_HB->SetMarkerStyle(20);
8733  energyhitSignal_HB->SetMarkerSize(0.4);
8734  energyhitSignal_HB->GetYaxis()->SetLabelSize(0.04);
8735  energyhitSignal_HB->SetXTitle("energyhitSignal_HB \b");
8736  energyhitSignal_HB->SetMarkerColor(2);
8737  energyhitSignal_HB->SetLineColor(0);
8738  gPad->SetGridy();
8739  gPad->SetGridx();
8740  energyhitSignal_HB->Draw("Error");
8741 
8743  c2x1->Update();
8744  c2x1->Print("RrecosignalGeneralD2PhiSymmetryHB.png");
8745  c2x1->Clear();
8746  // clean-up
8747  if (GefzRrecosignalHB42D)
8748  delete GefzRrecosignalHB42D;
8749  if (GefzRrecosignalHB42D0)
8750  delete GefzRrecosignalHB42D0;
8751  if (GefzRrecosignalHB42DF)
8752  delete GefzRrecosignalHB42DF;
8753  //====================================================================== 1D plot: R vs phi , averaged over depthfs & eta
8754  //======================================================================
8755  //cout<<" 1D plot: R vs phi , averaged over depthfs & eta *****" <<endl;
8756  c1x1->Clear();
8758  c1x1->Divide(1, 1);
8759  c1x1->cd(1);
8760  TH1F *GefzRrecosignalHB41D = new TH1F("GefzRrecosignalHB41D", "", nphi, 0., 72.);
8761  TH1F *GefzRrecosignalHB41D0 = new TH1F("GefzRrecosignalHB41D0", "", nphi, 0., 72.);
8762  TH1F *GefzRrecosignalHB41DF = (TH1F *)GefzRrecosignalHB41D0->Clone("GefzRrecosignalHB41DF");
8763  for (int jphi = 0; jphi < nphi; jphi++) {
8764  for (int jeta = 0; jeta < neta; jeta++) {
8765  for (int i = 0; i < ndepth; i++) {
8766  double ccc1 = arecosignalHB[i][jeta][jphi];
8767  if (ccc1 != 0.) {
8768  GefzRrecosignalHB41D->Fill(jphi, ccc1);
8769  GefzRrecosignalHB41D0->Fill(jphi, 1.);
8770  }
8771  }
8772  }
8773  }
8774  GefzRrecosignalHB41DF->Divide(
8775  GefzRrecosignalHB41D, GefzRrecosignalHB41D0, 1, 1, "B"); // R averaged over depthfs & eta
8776  GefzRrecosignalHB41D0->Sumw2();
8777  // for (int jphi=1;jphi<73;jphi++) {GefzRrecosignalHB41DF->SetBinError(jphi,0.01);}
8778  gPad->SetGridy();
8779  gPad->SetGridx(); // gPad->SetLogz();
8780  GefzRrecosignalHB41DF->SetMarkerStyle(20);
8781  GefzRrecosignalHB41DF->SetMarkerSize(1.4);
8782  GefzRrecosignalHB41DF->GetZaxis()->SetLabelSize(0.08);
8783  GefzRrecosignalHB41DF->SetXTitle("#phi \b");
8784  GefzRrecosignalHB41DF->SetYTitle(" <R> \b");
8785  GefzRrecosignalHB41DF->SetZTitle("<R>_PHI - AllDepthfs \b");
8786  GefzRrecosignalHB41DF->SetMarkerColor(4);
8787  GefzRrecosignalHB41DF->SetLineColor(
8788  4); // GefzRrecosignalHB41DF->SetMinimum(0.8); // GefzRrecosignalHB41DF->SetMaximum(1.000);
8789  GefzRrecosignalHB41DF->Draw("Error");
8791  c1x1->Update();
8792  c1x1->Print("RrecosignalGeneralD1PhiSymmetryHB.png");
8793  c1x1->Clear();
8794  // clean-up
8795  if (GefzRrecosignalHB41D)
8796  delete GefzRrecosignalHB41D;
8797  if (GefzRrecosignalHB41D0)
8798  delete GefzRrecosignalHB41D0;
8799  if (GefzRrecosignalHB41DF)
8800  delete GefzRrecosignalHB41DF;
8801  //========================================================================================== 4
8802  //======================================================================
8803  //======================================================================1D plot: R vs phi , different eta, depth=1
8804  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
8805  c3x5->Clear();
8807  c3x5->Divide(4, 4);
8808  c3x5->cd(1);
8809  int kcountHBpositivedirectionRecosignal1 = 1;
8810  TH1F *h2CeffHBpositivedirectionRecosignal1 = new TH1F("h2CeffHBpositivedirectionRecosignal1", "", nphi, 0., 72.);
8811  for (int jeta = 0; jeta < njeta; jeta++) {
8812  // positivedirectionRecosignal:
8813  if (jeta - 41 >= 0) {
8814  // for (int i=0;i<ndepth;i++) {
8815  // depth=1
8816  for (int i = 0; i < 1; i++) {
8817  TH1F *HBpositivedirectionRecosignal1 = (TH1F *)h2CeffHBpositivedirectionRecosignal1->Clone("twod1");
8818  float ccctest = 0; // to avoid empty massive elements
8819  for (int jphi = 0; jphi < nphi; jphi++) {
8820  double ccc1 = arecosignalHB[i][jeta][jphi];
8821  if (ccc1 != 0.) {
8822  HBpositivedirectionRecosignal1->Fill(jphi, ccc1);
8823  ccctest = 1.; //HBpositivedirectionRecosignal1->SetBinError(i,0.01);
8824  }
8825  } // for jphi
8826  if (ccctest > 0.) {
8827  // cout<<"444 kcountHBpositivedirectionRecosignal1 = "<<kcountHBpositivedirectionRecosignal1 <<" jeta-41= "<< jeta-41 <<endl;
8828  c3x5->cd(kcountHBpositivedirectionRecosignal1);
8829  HBpositivedirectionRecosignal1->SetMarkerStyle(20);
8830  HBpositivedirectionRecosignal1->SetMarkerSize(0.4);
8831  HBpositivedirectionRecosignal1->GetYaxis()->SetLabelSize(0.04);
8832  HBpositivedirectionRecosignal1->SetXTitle("HBpositivedirectionRecosignal1 \b");
8833  HBpositivedirectionRecosignal1->SetMarkerColor(2);
8834  HBpositivedirectionRecosignal1->SetLineColor(0);
8835  gPad->SetGridy();
8836  gPad->SetGridx();
8837  // gPad->SetLogy();
8838  if (kcountHBpositivedirectionRecosignal1 == 1)
8839  HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 0; depth = 1 \b");
8840  if (kcountHBpositivedirectionRecosignal1 == 2)
8841  HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 1; depth = 1 \b");
8842  if (kcountHBpositivedirectionRecosignal1 == 3)
8843  HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 2; depth = 1 \b");
8844  if (kcountHBpositivedirectionRecosignal1 == 4)
8845  HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 3; depth = 1 \b");
8846  if (kcountHBpositivedirectionRecosignal1 == 5)
8847  HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 4; depth = 1 \b");
8848  if (kcountHBpositivedirectionRecosignal1 == 6)
8849  HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 5; depth = 1 \b");
8850  if (kcountHBpositivedirectionRecosignal1 == 7)
8851  HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 6; depth = 1 \b");
8852  if (kcountHBpositivedirectionRecosignal1 == 8)
8853  HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 7; depth = 1 \b");
8854  if (kcountHBpositivedirectionRecosignal1 == 9)
8855  HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 8; depth = 1 \b");
8856  if (kcountHBpositivedirectionRecosignal1 == 10)
8857  HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 9; depth = 1 \b");
8858  if (kcountHBpositivedirectionRecosignal1 == 11)
8859  HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 10; depth = 1 \b");
8860  if (kcountHBpositivedirectionRecosignal1 == 12)
8861  HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 11; depth = 1 \b");
8862  if (kcountHBpositivedirectionRecosignal1 == 13)
8863  HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 12; depth = 1 \b");
8864  if (kcountHBpositivedirectionRecosignal1 == 14)
8865  HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 13; depth = 1 \b");
8866  if (kcountHBpositivedirectionRecosignal1 == 15)
8867  HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 14; depth = 1 \b");
8868  if (kcountHBpositivedirectionRecosignal1 == 16)
8869  HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 15; depth = 1 \b");
8870  HBpositivedirectionRecosignal1->Draw("Error");
8871  kcountHBpositivedirectionRecosignal1++;
8872  if (kcountHBpositivedirectionRecosignal1 > 16)
8873  break; //
8874  } //ccctest>0
8875 
8876  } // for i
8877  } //if(jeta-41 >= 0)
8878  } //for jeta
8880  c3x5->Update();
8881  c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth1HB.png");
8882  c3x5->Clear();
8883  // clean-up
8884  if (h2CeffHBpositivedirectionRecosignal1)
8885  delete h2CeffHBpositivedirectionRecosignal1;
8886 
8887  //========================================================================================== 5
8888  //======================================================================
8889  //======================================================================1D plot: R vs phi , different eta, depth=2
8890  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
8891  c3x5->Clear();
8893  c3x5->Divide(4, 4);
8894  c3x5->cd(1);
8895  int kcountHBpositivedirectionRecosignal2 = 1;
8896  TH1F *h2CeffHBpositivedirectionRecosignal2 = new TH1F("h2CeffHBpositivedirectionRecosignal2", "", nphi, 0., 72.);
8897  for (int jeta = 0; jeta < njeta; jeta++) {
8898  // positivedirectionRecosignal:
8899  if (jeta - 41 >= 0) {
8900  // for (int i=0;i<ndepth;i++) {
8901  // depth=2
8902  for (int i = 1; i < 2; i++) {
8903  TH1F *HBpositivedirectionRecosignal2 = (TH1F *)h2CeffHBpositivedirectionRecosignal2->Clone("twod1");
8904  float ccctest = 0; // to avoid empty massive elements
8905  for (int jphi = 0; jphi < nphi; jphi++) {
8906  double ccc1 = arecosignalHB[i][jeta][jphi];
8907  if (ccc1 != 0.) {
8908  HBpositivedirectionRecosignal2->Fill(jphi, ccc1);
8909  ccctest = 1.; //HBpositivedirectionRecosignal2->SetBinError(i,0.01);
8910  }
8911  } // for jphi
8912  if (ccctest > 0.) {
8913  //cout<<"555 kcountHBpositivedirectionRecosignal2 = "<<kcountHBpositivedirectionRecosignal2 <<" jeta-41= "<< jeta-41 <<endl;
8914  c3x5->cd(kcountHBpositivedirectionRecosignal2);
8915  HBpositivedirectionRecosignal2->SetMarkerStyle(20);
8916  HBpositivedirectionRecosignal2->SetMarkerSize(0.4);
8917  HBpositivedirectionRecosignal2->GetYaxis()->SetLabelSize(0.04);
8918  HBpositivedirectionRecosignal2->SetXTitle("HBpositivedirectionRecosignal2 \b");
8919  HBpositivedirectionRecosignal2->SetMarkerColor(2);
8920  HBpositivedirectionRecosignal2->SetLineColor(0);
8921  gPad->SetGridy();
8922  gPad->SetGridx();
8923  // gPad->SetLogy();
8924  if (kcountHBpositivedirectionRecosignal2 == 1)
8925  HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 0; depth = 2 \b");
8926  if (kcountHBpositivedirectionRecosignal2 == 2)
8927  HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 1; depth = 2 \b");
8928  if (kcountHBpositivedirectionRecosignal2 == 3)
8929  HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 2; depth = 2 \b");
8930  if (kcountHBpositivedirectionRecosignal2 == 4)
8931  HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 3; depth = 2 \b");
8932  if (kcountHBpositivedirectionRecosignal2 == 5)
8933  HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 4; depth = 2 \b");
8934  if (kcountHBpositivedirectionRecosignal2 == 6)
8935  HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 5; depth = 2 \b");
8936  if (kcountHBpositivedirectionRecosignal2 == 7)
8937  HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 6; depth = 2 \b");
8938  if (kcountHBpositivedirectionRecosignal2 == 8)
8939  HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 7; depth = 2 \b");
8940  if (kcountHBpositivedirectionRecosignal2 == 9)
8941  HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 8; depth = 2 \b");
8942  if (kcountHBpositivedirectionRecosignal2 == 10)
8943  HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 9; depth = 2 \b");
8944  if (kcountHBpositivedirectionRecosignal2 == 11)
8945  HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 10; depth = 2 \b");
8946  if (kcountHBpositivedirectionRecosignal2 == 12)
8947  HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 11; depth = 2 \b");
8948  if (kcountHBpositivedirectionRecosignal2 == 13)
8949  HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 12; depth = 2 \b");
8950  if (kcountHBpositivedirectionRecosignal2 == 14)
8951  HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 13; depth = 2 \b");
8952  if (kcountHBpositivedirectionRecosignal2 == 15)
8953  HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 14; depth = 2 \b");
8954  if (kcountHBpositivedirectionRecosignal2 == 16)
8955  HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 15; depth = 2 \b");
8956  HBpositivedirectionRecosignal2->Draw("Error");
8957  kcountHBpositivedirectionRecosignal2++;
8958  if (kcountHBpositivedirectionRecosignal2 > 16)
8959  break; // 4x6 = 24
8960  } //ccctest>0
8961 
8962  } // for i
8963  } //if(jeta-41 >= 0)
8964  } //for jeta
8966  c3x5->Update();
8967  c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth2HB.png");
8968  c3x5->Clear();
8969  // clean-up
8970  if (h2CeffHBpositivedirectionRecosignal2)
8971  delete h2CeffHBpositivedirectionRecosignal2;
8972  //========================================================================================== 6
8973  //======================================================================
8974  //======================================================================1D plot: R vs phi , different eta, depth=3
8975  //cout<<" 1D plot: R vs phi , different eta, depth=3 *****" <<endl;
8976  c3x5->Clear();
8978  c3x5->Divide(4, 4);
8979  c3x5->cd(1);
8980  int kcountHBpositivedirectionRecosignal3 = 1;
8981  TH1F *h2CeffHBpositivedirectionRecosignal3 = new TH1F("h2CeffHBpositivedirectionRecosignal3", "", nphi, 0., 72.);
8982  for (int jeta = 0; jeta < njeta; jeta++) {
8983  // positivedirectionRecosignal:
8984  if (jeta - 41 >= 0) {
8985  // for (int i=0;i<ndepth;i++) {
8986  // depth=3
8987  for (int i = 2; i < 3; i++) {
8988  TH1F *HBpositivedirectionRecosignal3 = (TH1F *)h2CeffHBpositivedirectionRecosignal3->Clone("twod1");
8989  float ccctest = 0; // to avoid empty massive elements
8990  for (int jphi = 0; jphi < nphi; jphi++) {
8991  double ccc1 = arecosignalHB[i][jeta][jphi];
8992  if (ccc1 != 0.) {
8993  HBpositivedirectionRecosignal3->Fill(jphi, ccc1);
8994  ccctest = 1.; //HBpositivedirectionRecosignal3->SetBinError(i,0.01);
8995  }
8996  } // for jphi
8997  if (ccctest > 0.) {
8998  //cout<<"666 kcountHBpositivedirectionRecosignal3 = "<<kcountHBpositivedirectionRecosignal3 <<" jeta-41= "<< jeta-41 <<endl;
8999  c3x5->cd(kcountHBpositivedirectionRecosignal3);
9000  HBpositivedirectionRecosignal3->SetMarkerStyle(20);
9001  HBpositivedirectionRecosignal3->SetMarkerSize(0.4);
9002  HBpositivedirectionRecosignal3->GetYaxis()->SetLabelSize(0.04);
9003  HBpositivedirectionRecosignal3->SetXTitle("HBpositivedirectionRecosignal3 \b");
9004  HBpositivedirectionRecosignal3->SetMarkerColor(2);
9005  HBpositivedirectionRecosignal3->SetLineColor(0);
9006  gPad->SetGridy();
9007  gPad->SetGridx();
9008  // gPad->SetLogy();
9009  if (kcountHBpositivedirectionRecosignal3 == 1)
9010  HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 0; depth = 3 \b");
9011  if (kcountHBpositivedirectionRecosignal3 == 2)
9012  HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 1; depth = 3 \b");
9013  if (kcountHBpositivedirectionRecosignal3 == 3)
9014  HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 2; depth = 3 \b");
9015  if (kcountHBpositivedirectionRecosignal3 == 4)
9016  HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 3; depth = 3 \b");
9017  if (kcountHBpositivedirectionRecosignal3 == 5)
9018  HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 4; depth = 3 \b");
9019  if (kcountHBpositivedirectionRecosignal3 == 6)
9020  HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 5; depth = 3 \b");
9021  if (kcountHBpositivedirectionRecosignal3 == 7)
9022  HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 6; depth = 3 \b");
9023  if (kcountHBpositivedirectionRecosignal3 == 8)
9024  HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 7; depth = 3 \b");
9025  if (kcountHBpositivedirectionRecosignal3 == 9)
9026  HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 8; depth = 3 \b");
9027  if (kcountHBpositivedirectionRecosignal3 == 10)
9028  HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 9; depth = 3 \b");
9029  if (kcountHBpositivedirectionRecosignal3 == 11)
9030  HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 0; depth = 3 \b");
9031  if (kcountHBpositivedirectionRecosignal3 == 12)
9032  HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 11; depth = 3 \b");
9033  if (kcountHBpositivedirectionRecosignal3 == 13)
9034  HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 12; depth = 3 \b");
9035  if (kcountHBpositivedirectionRecosignal3 == 14)
9036  HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 13; depth = 3 \b");
9037  if (kcountHBpositivedirectionRecosignal3 == 15)
9038  HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 14; depth = 3 \b");
9039  if (kcountHBpositivedirectionRecosignal3 == 16)
9040  HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 15; depth = 3 \b");
9041  HBpositivedirectionRecosignal3->Draw("Error");
9042  kcountHBpositivedirectionRecosignal3++;
9043  if (kcountHBpositivedirectionRecosignal3 > 16)
9044  break; // 4x6 = 24
9045  } //ccctest>0
9046 
9047  } // for i
9048  } //if(jeta-41 >= 0)
9049  } //for jeta
9051  c3x5->Update();
9052  c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth3HB.png");
9053  c3x5->Clear();
9054  // clean-up
9055  if (h2CeffHBpositivedirectionRecosignal3)
9056  delete h2CeffHBpositivedirectionRecosignal3;
9057  //========================================================================================== 7
9058  //======================================================================
9059  //======================================================================1D plot: R vs phi , different eta, depth=4
9060  //cout<<" 1D plot: R vs phi , different eta, depth=4 *****" <<endl;
9061  c3x5->Clear();
9063  c3x5->Divide(4, 4);
9064  c3x5->cd(1);
9065  int kcountHBpositivedirectionRecosignal4 = 1;
9066  TH1F *h2CeffHBpositivedirectionRecosignal4 = new TH1F("h2CeffHBpositivedirectionRecosignal4", "", nphi, 0., 72.);
9067 
9068  for (int jeta = 0; jeta < njeta; jeta++) {
9069  // positivedirectionRecosignal:
9070  if (jeta - 41 >= 0) {
9071  // for (int i=0;i<ndepth;i++) {
9072  // depth=4
9073  for (int i = 3; i < 4; i++) {
9074  TH1F *HBpositivedirectionRecosignal4 = (TH1F *)h2CeffHBpositivedirectionRecosignal4->Clone("twod1");
9075 
9076  float ccctest = 0; // to avoid empty massive elements
9077  for (int jphi = 0; jphi < nphi; jphi++) {
9078  double ccc1 = arecosignalHB[i][jeta][jphi];
9079  if (ccc1 != 0.) {
9080  HBpositivedirectionRecosignal4->Fill(jphi, ccc1);
9081  ccctest = 1.; //HBpositivedirectionRecosignal4->SetBinError(i,0.01);
9082  }
9083  } // for jphi
9084  if (ccctest > 0.) {
9085  //cout<<"777 kcountHBpositivedirectionRecosignal4 = "<<kcountHBpositivedirectionRecosignal4 <<" jeta-41= "<< jeta-41 <<endl;
9086  c3x5->cd(kcountHBpositivedirectionRecosignal4);
9087  HBpositivedirectionRecosignal4->SetMarkerStyle(20);
9088  HBpositivedirectionRecosignal4->SetMarkerSize(0.4);
9089  HBpositivedirectionRecosignal4->GetYaxis()->SetLabelSize(0.04);
9090  HBpositivedirectionRecosignal4->SetXTitle("HBpositivedirectionRecosignal4 \b");
9091  HBpositivedirectionRecosignal4->SetMarkerColor(2);
9092  HBpositivedirectionRecosignal4->SetLineColor(0);
9093  gPad->SetGridy();
9094  gPad->SetGridx();
9095  // gPad->SetLogy();
9096  if (kcountHBpositivedirectionRecosignal4 == 1)
9097  HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 0; depth = 4 \b");
9098  if (kcountHBpositivedirectionRecosignal4 == 2)
9099  HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 1; depth = 4 \b");
9100  if (kcountHBpositivedirectionRecosignal4 == 3)
9101  HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 2; depth = 4 \b");
9102  if (kcountHBpositivedirectionRecosignal4 == 4)
9103  HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 3; depth = 4 \b");
9104  if (kcountHBpositivedirectionRecosignal4 == 5)
9105  HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 4; depth = 4 \b");
9106  if (kcountHBpositivedirectionRecosignal4 == 6)
9107  HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 5; depth = 4 \b");
9108  if (kcountHBpositivedirectionRecosignal4 == 7)
9109  HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 6; depth = 4 \b");
9110  if (kcountHBpositivedirectionRecosignal4 == 8)
9111  HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 7; depth = 4 \b");
9112  if (kcountHBpositivedirectionRecosignal4 == 9)
9113  HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 8; depth = 4 \b");
9114  if (kcountHBpositivedirectionRecosignal4 == 10)
9115  HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 9; depth = 4 \b");
9116  if (kcountHBpositivedirectionRecosignal4 == 11)
9117  HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 10; depth = 4 \b");
9118  if (kcountHBpositivedirectionRecosignal4 == 12)
9119  HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 11; depth = 4 \b");
9120  if (kcountHBpositivedirectionRecosignal4 == 13)
9121  HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 12; depth = 4 \b");
9122  if (kcountHBpositivedirectionRecosignal4 == 14)
9123  HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 13; depth = 4 \b");
9124  if (kcountHBpositivedirectionRecosignal4 == 15)
9125  HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 14; depth = 4 \b");
9126  if (kcountHBpositivedirectionRecosignal4 == 16)
9127  HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 15; depth = 4 \b");
9128  HBpositivedirectionRecosignal4->Draw("Error");
9129  kcountHBpositivedirectionRecosignal4++;
9130  if (kcountHBpositivedirectionRecosignal4 > 16)
9131  break; // 4x6 = 24
9132  } //ccctest>0
9133 
9134  } // for i
9135  } //if(jeta-41 >= 0)
9136  } //for jeta
9138  c3x5->Update();
9139  c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth4HB.png");
9140  c3x5->Clear();
9141  // clean-up
9142  if (h2CeffHBpositivedirectionRecosignal4)
9143  delete h2CeffHBpositivedirectionRecosignal4;
9144 
9145  //========================================================================================== 1114
9146  //======================================================================
9147  //======================================================================1D plot: R vs phi , different eta, depth=1
9148  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
9149  c3x5->Clear();
9151  c3x5->Divide(4, 4);
9152  c3x5->cd(1);
9153  int kcountHBnegativedirectionRecosignal1 = 1;
9154  TH1F *h2CeffHBnegativedirectionRecosignal1 = new TH1F("h2CeffHBnegativedirectionRecosignal1", "", nphi, 0., 72.);
9155  for (int jeta = 0; jeta < njeta; jeta++) {
9156  // negativedirectionRecosignal:
9157  if (jeta - 41 < 0) {
9158  // for (int i=0;i<ndepth;i++) {
9159  // depth=1
9160  for (int i = 0; i < 1; i++) {
9161  TH1F *HBnegativedirectionRecosignal1 = (TH1F *)h2CeffHBnegativedirectionRecosignal1->Clone("twod1");
9162  float ccctest = 0; // to avoid empty massive elements
9163  for (int jphi = 0; jphi < nphi; jphi++) {
9164  double ccc1 = arecosignalHB[i][jeta][jphi];
9165  if (ccc1 != 0.) {
9166  HBnegativedirectionRecosignal1->Fill(jphi, ccc1);
9167  ccctest = 1.; //HBnegativedirectionRecosignal1->SetBinError(i,0.01);
9168  }
9169  } // for jphi
9170  if (ccctest > 0.) {
9171  // cout<<"444 kcountHBnegativedirectionRecosignal1 = "<<kcountHBnegativedirectionRecosignal1 <<" jeta-41= "<< jeta-41 <<endl;
9172  c3x5->cd(kcountHBnegativedirectionRecosignal1);
9173  HBnegativedirectionRecosignal1->SetMarkerStyle(20);
9174  HBnegativedirectionRecosignal1->SetMarkerSize(0.4);
9175  HBnegativedirectionRecosignal1->GetYaxis()->SetLabelSize(0.04);
9176  HBnegativedirectionRecosignal1->SetXTitle("HBnegativedirectionRecosignal1 \b");
9177  HBnegativedirectionRecosignal1->SetMarkerColor(2);
9178  HBnegativedirectionRecosignal1->SetLineColor(0);
9179  gPad->SetGridy();
9180  gPad->SetGridx();
9181  // gPad->SetLogy();
9182  if (kcountHBnegativedirectionRecosignal1 == 1)
9183  HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -16; depth = 1 \b");
9184  if (kcountHBnegativedirectionRecosignal1 == 2)
9185  HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -15; depth = 1 \b");
9186  if (kcountHBnegativedirectionRecosignal1 == 3)
9187  HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -14; depth = 1 \b");
9188  if (kcountHBnegativedirectionRecosignal1 == 4)
9189  HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -13; depth = 1 \b");
9190  if (kcountHBnegativedirectionRecosignal1 == 5)
9191  HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -12; depth = 1 \b");
9192  if (kcountHBnegativedirectionRecosignal1 == 6)
9193  HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -11; depth = 1 \b");
9194  if (kcountHBnegativedirectionRecosignal1 == 7)
9195  HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -10; depth = 1 \b");
9196  if (kcountHBnegativedirectionRecosignal1 == 8)
9197  HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -9; depth = 1 \b");
9198  if (kcountHBnegativedirectionRecosignal1 == 9)
9199  HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -8; depth = 1 \b");
9200  if (kcountHBnegativedirectionRecosignal1 == 10)
9201  HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -7; depth = 1 \b");
9202  if (kcountHBnegativedirectionRecosignal1 == 11)
9203  HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -6; depth = 1 \b");
9204  if (kcountHBnegativedirectionRecosignal1 == 12)
9205  HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -5; depth = 1 \b");
9206  if (kcountHBnegativedirectionRecosignal1 == 13)
9207  HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -4; depth = 1 \b");
9208  if (kcountHBnegativedirectionRecosignal1 == 14)
9209  HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -3; depth = 1 \b");
9210  if (kcountHBnegativedirectionRecosignal1 == 15)
9211  HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -2; depth = 1 \b");
9212  if (kcountHBnegativedirectionRecosignal1 == 16)
9213  HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -1; depth = 1 \b");
9214  HBnegativedirectionRecosignal1->Draw("Error");
9215  kcountHBnegativedirectionRecosignal1++;
9216  if (kcountHBnegativedirectionRecosignal1 > 16)
9217  break; //
9218  } //ccctest>0
9219 
9220  } // for i
9221  } //if(jeta-41 < 0 )
9222  } //for jeta
9224  c3x5->Update();
9225  c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth1HB.png");
9226  c3x5->Clear();
9227  // clean-up
9228  if (h2CeffHBnegativedirectionRecosignal1)
9229  delete h2CeffHBnegativedirectionRecosignal1;
9230 
9231  //========================================================================================== 1115
9232  //======================================================================
9233  //======================================================================1D plot: R vs phi , different eta, depth=2
9234  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
9235  c3x5->Clear();
9237  c3x5->Divide(4, 4);
9238  c3x5->cd(1);
9239  int kcountHBnegativedirectionRecosignal2 = 1;
9240  TH1F *h2CeffHBnegativedirectionRecosignal2 = new TH1F("h2CeffHBnegativedirectionRecosignal2", "", nphi, 0., 72.);
9241  for (int jeta = 0; jeta < njeta; jeta++) {
9242  // negativedirectionRecosignal:
9243  if (jeta - 41 < 0) {
9244  // for (int i=0;i<ndepth;i++) {
9245  // depth=2
9246  for (int i = 1; i < 2; i++) {
9247  TH1F *HBnegativedirectionRecosignal2 = (TH1F *)h2CeffHBnegativedirectionRecosignal2->Clone("twod1");
9248  float ccctest = 0; // to avoid empty massive elements
9249  for (int jphi = 0; jphi < nphi; jphi++) {
9250  double ccc1 = arecosignalHB[i][jeta][jphi];
9251  if (ccc1 != 0.) {
9252  HBnegativedirectionRecosignal2->Fill(jphi, ccc1);
9253  ccctest = 1.; //HBnegativedirectionRecosignal2->SetBinError(i,0.01);
9254  }
9255  } // for jphi
9256  if (ccctest > 0.) {
9257  //cout<<"555 kcountHBnegativedirectionRecosignal2 = "<<kcountHBnegativedirectionRecosignal2 <<" jeta-41= "<< jeta-41 <<endl;
9258  c3x5->cd(kcountHBnegativedirectionRecosignal2);
9259  HBnegativedirectionRecosignal2->SetMarkerStyle(20);
9260  HBnegativedirectionRecosignal2->SetMarkerSize(0.4);
9261  HBnegativedirectionRecosignal2->GetYaxis()->SetLabelSize(0.04);
9262  HBnegativedirectionRecosignal2->SetXTitle("HBnegativedirectionRecosignal2 \b");
9263  HBnegativedirectionRecosignal2->SetMarkerColor(2);
9264  HBnegativedirectionRecosignal2->SetLineColor(0);
9265  gPad->SetGridy();
9266  gPad->SetGridx();
9267  // gPad->SetLogy();
9268  if (kcountHBnegativedirectionRecosignal2 == 1)
9269  HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -16; depth = 2 \b");
9270  if (kcountHBnegativedirectionRecosignal2 == 2)
9271  HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -15; depth = 2 \b");
9272  if (kcountHBnegativedirectionRecosignal2 == 3)
9273  HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -14; depth = 2 \b");
9274  if (kcountHBnegativedirectionRecosignal2 == 4)
9275  HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -13; depth = 2 \b");
9276  if (kcountHBnegativedirectionRecosignal2 == 5)
9277  HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -12; depth = 2 \b");
9278  if (kcountHBnegativedirectionRecosignal2 == 6)
9279  HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -11; depth = 2 \b");
9280  if (kcountHBnegativedirectionRecosignal2 == 7)
9281  HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -10; depth = 2 \b");
9282  if (kcountHBnegativedirectionRecosignal2 == 8)
9283  HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -9; depth = 2 \b");
9284  if (kcountHBnegativedirectionRecosignal2 == 9)
9285  HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -8; depth = 2 \b");
9286  if (kcountHBnegativedirectionRecosignal2 == 10)
9287  HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -7; depth = 2 \b");
9288  if (kcountHBnegativedirectionRecosignal2 == 11)
9289  HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -6; depth = 2 \b");
9290  if (kcountHBnegativedirectionRecosignal2 == 12)
9291  HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -5; depth = 2 \b");
9292  if (kcountHBnegativedirectionRecosignal2 == 13)
9293  HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -4; depth = 2 \b");
9294  if (kcountHBnegativedirectionRecosignal2 == 14)
9295  HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -3; depth = 2 \b");
9296  if (kcountHBnegativedirectionRecosignal2 == 15)
9297  HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -2; depth = 2 \b");
9298  if (kcountHBnegativedirectionRecosignal2 == 16)
9299  HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -1; depth = 2 \b");
9300  HBnegativedirectionRecosignal2->Draw("Error");
9301  kcountHBnegativedirectionRecosignal2++;
9302  if (kcountHBnegativedirectionRecosignal2 > 16)
9303  break; // 4x6 = 24
9304  } //ccctest>0
9305 
9306  } // for i
9307  } //if(jeta-41 < 0 )
9308  } //for jeta
9310  c3x5->Update();
9311  c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth2HB.png");
9312  c3x5->Clear();
9313  // clean-up
9314  if (h2CeffHBnegativedirectionRecosignal2)
9315  delete h2CeffHBnegativedirectionRecosignal2;
9316  //========================================================================================== 1116
9317  //======================================================================
9318  //======================================================================1D plot: R vs phi , different eta, depth=3
9319  //cout<<" 1D plot: R vs phi , different eta, depth=3 *****" <<endl;
9320  c3x5->Clear();
9322  c3x5->Divide(4, 4);
9323  c3x5->cd(1);
9324  int kcountHBnegativedirectionRecosignal3 = 1;
9325  TH1F *h2CeffHBnegativedirectionRecosignal3 = new TH1F("h2CeffHBnegativedirectionRecosignal3", "", nphi, 0., 72.);
9326  for (int jeta = 0; jeta < njeta; jeta++) {
9327  // negativedirectionRecosignal:
9328  if (jeta - 41 < 0) {
9329  // for (int i=0;i<ndepth;i++) {
9330  // depth=3
9331  for (int i = 2; i < 3; i++) {
9332  TH1F *HBnegativedirectionRecosignal3 = (TH1F *)h2CeffHBnegativedirectionRecosignal3->Clone("twod1");
9333  float ccctest = 0; // to avoid empty massive elements
9334  for (int jphi = 0; jphi < nphi; jphi++) {
9335  double ccc1 = arecosignalHB[i][jeta][jphi];
9336  if (ccc1 != 0.) {
9337  HBnegativedirectionRecosignal3->Fill(jphi, ccc1);
9338  ccctest = 1.; //HBnegativedirectionRecosignal3->SetBinError(i,0.01);
9339  }
9340  } // for jphi
9341  if (ccctest > 0.) {
9342  //cout<<"666 kcountHBnegativedirectionRecosignal3 = "<<kcountHBnegativedirectionRecosignal3 <<" jeta-41= "<< jeta-41 <<endl;
9343  c3x5->cd(kcountHBnegativedirectionRecosignal3);
9344  HBnegativedirectionRecosignal3->SetMarkerStyle(20);
9345  HBnegativedirectionRecosignal3->SetMarkerSize(0.4);
9346  HBnegativedirectionRecosignal3->GetYaxis()->SetLabelSize(0.04);
9347  HBnegativedirectionRecosignal3->SetXTitle("HBnegativedirectionRecosignal3 \b");
9348  HBnegativedirectionRecosignal3->SetMarkerColor(2);
9349  HBnegativedirectionRecosignal3->SetLineColor(0);
9350  gPad->SetGridy();
9351  gPad->SetGridx();
9352  // gPad->SetLogy();
9353  if (kcountHBnegativedirectionRecosignal3 == 1)
9354  HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -16; depth = 3 \b");
9355  if (kcountHBnegativedirectionRecosignal3 == 2)
9356  HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -15; depth = 3 \b");
9357  if (kcountHBnegativedirectionRecosignal3 == 3)
9358  HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -14; depth = 3 \b");
9359  if (kcountHBnegativedirectionRecosignal3 == 4)
9360  HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -13; depth = 3 \b");
9361  if (kcountHBnegativedirectionRecosignal3 == 5)
9362  HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -12; depth = 3 \b");
9363  if (kcountHBnegativedirectionRecosignal3 == 6)
9364  HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -11; depth = 3 \b");
9365  if (kcountHBnegativedirectionRecosignal3 == 7)
9366  HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -10; depth = 3 \b");
9367  if (kcountHBnegativedirectionRecosignal3 == 8)
9368  HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -9; depth = 3 \b");
9369  if (kcountHBnegativedirectionRecosignal3 == 9)
9370  HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -8; depth = 3 \b");
9371  if (kcountHBnegativedirectionRecosignal3 == 10)
9372  HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -7; depth = 3 \b");
9373  if (kcountHBnegativedirectionRecosignal3 == 11)
9374  HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -6; depth = 3 \b");
9375  if (kcountHBnegativedirectionRecosignal3 == 12)
9376  HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -5; depth = 3 \b");
9377  if (kcountHBnegativedirectionRecosignal3 == 13)
9378  HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -4; depth = 3 \b");
9379  if (kcountHBnegativedirectionRecosignal3 == 14)
9380  HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -3; depth = 3 \b");
9381  if (kcountHBnegativedirectionRecosignal3 == 15)
9382  HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -2; depth = 3 \b");
9383  if (kcountHBnegativedirectionRecosignal3 == 16)
9384  HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -1; depth = 3 \b");
9385 
9386  HBnegativedirectionRecosignal3->Draw("Error");
9387  kcountHBnegativedirectionRecosignal3++;
9388  if (kcountHBnegativedirectionRecosignal3 > 16)
9389  break; // 4x6 = 24
9390  } //ccctest>0
9391 
9392  } // for i
9393  } //if(jeta-41 < 0 )
9394  } //for jeta
9396  c3x5->Update();
9397  c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth3HB.png");
9398  c3x5->Clear();
9399  // clean-up
9400  if (h2CeffHBnegativedirectionRecosignal3)
9401  delete h2CeffHBnegativedirectionRecosignal3;
9402  //========================================================================================== 1117
9403  //======================================================================
9404  //======================================================================1D plot: R vs phi , different eta, depth=4
9405  //cout<<" 1D plot: R vs phi , different eta, depth=4 *****" <<endl;
9406  c3x5->Clear();
9408  c3x5->Divide(4, 4);
9409  c3x5->cd(1);
9410  int kcountHBnegativedirectionRecosignal4 = 1;
9411  TH1F *h2CeffHBnegativedirectionRecosignal4 = new TH1F("h2CeffHBnegativedirectionRecosignal4", "", nphi, 0., 72.);
9412 
9413  for (int jeta = 0; jeta < njeta; jeta++) {
9414  // negativedirectionRecosignal:
9415  if (jeta - 41 < 0) {
9416  // for (int i=0;i<ndepth;i++) {
9417  // depth=4
9418  for (int i = 3; i < 4; i++) {
9419  TH1F *HBnegativedirectionRecosignal4 = (TH1F *)h2CeffHBnegativedirectionRecosignal4->Clone("twod1");
9420 
9421  float ccctest = 0; // to avoid empty massive elements
9422  for (int jphi = 0; jphi < nphi; jphi++) {
9423  double ccc1 = arecosignalHB[i][jeta][jphi];
9424  if (ccc1 != 0.) {
9425  HBnegativedirectionRecosignal4->Fill(jphi, ccc1);
9426  ccctest = 1.; //HBnegativedirectionRecosignal4->SetBinError(i,0.01);
9427  }
9428  } // for jphi
9429  if (ccctest > 0.) {
9430  //cout<<"777 kcountHBnegativedirectionRecosignal4 = "<<kcountHBnegativedirectionRecosignal4 <<" jeta-41= "<< jeta-41 <<endl;
9431  c3x5->cd(kcountHBnegativedirectionRecosignal4);
9432  HBnegativedirectionRecosignal4->SetMarkerStyle(20);
9433  HBnegativedirectionRecosignal4->SetMarkerSize(0.4);
9434  HBnegativedirectionRecosignal4->GetYaxis()->SetLabelSize(0.04);
9435  HBnegativedirectionRecosignal4->SetXTitle("HBnegativedirectionRecosignal4 \b");
9436  HBnegativedirectionRecosignal4->SetMarkerColor(2);
9437  HBnegativedirectionRecosignal4->SetLineColor(0);
9438  gPad->SetGridy();
9439  gPad->SetGridx();
9440  // gPad->SetLogy();
9441  if (kcountHBnegativedirectionRecosignal4 == 1)
9442  HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -16; depth = 4 \b");
9443  if (kcountHBnegativedirectionRecosignal4 == 2)
9444  HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -15; depth = 4 \b");
9445  if (kcountHBnegativedirectionRecosignal4 == 3)
9446  HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -14; depth = 4 \b");
9447  if (kcountHBnegativedirectionRecosignal4 == 4)
9448  HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -13; depth = 4 \b");
9449  if (kcountHBnegativedirectionRecosignal4 == 5)
9450  HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -12; depth = 4 \b");
9451  if (kcountHBnegativedirectionRecosignal4 == 6)
9452  HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -11; depth = 4 \b");
9453  if (kcountHBnegativedirectionRecosignal4 == 7)
9454  HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -10; depth = 4 \b");
9455  if (kcountHBnegativedirectionRecosignal4 == 8)
9456  HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -9; depth = 4 \b");
9457  if (kcountHBnegativedirectionRecosignal4 == 9)
9458  HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -8; depth = 4 \b");
9459  if (kcountHBnegativedirectionRecosignal4 == 10)
9460  HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -7; depth = 4 \b");
9461  if (kcountHBnegativedirectionRecosignal4 == 11)
9462  HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -6; depth = 4 \b");
9463  if (kcountHBnegativedirectionRecosignal4 == 12)
9464  HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -5; depth = 4 \b");
9465  if (kcountHBnegativedirectionRecosignal4 == 13)
9466  HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -4; depth = 4 \b");
9467  if (kcountHBnegativedirectionRecosignal4 == 14)
9468  HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -3; depth = 4 \b");
9469  if (kcountHBnegativedirectionRecosignal4 == 15)
9470  HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -2; depth = 4 \b");
9471  if (kcountHBnegativedirectionRecosignal4 == 16)
9472  HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -1; depth = 4 \b");
9473  HBnegativedirectionRecosignal4->Draw("Error");
9474  kcountHBnegativedirectionRecosignal4++;
9475  if (kcountHBnegativedirectionRecosignal4 > 16)
9476  break; // 4x6 = 24
9477  } //ccctest>0
9478 
9479  } // for i
9480  } //if(jeta-41 < 0 )
9481  } //for jeta
9483  c3x5->Update();
9484  c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth4HB.png");
9485  c3x5->Clear();
9486  // clean-up
9487  if (h2CeffHBnegativedirectionRecosignal4)
9488  delete h2CeffHBnegativedirectionRecosignal4;
9489 
9490  //======================================================================================================================
9491  //======================================================================================================================
9492  //======================================================================================================================
9493  // DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD:
9494 
9495  //cout<<" Start Vaiance: preparation *****" <<endl;
9496  TH2F *recosignalVariance1HB1 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy2_HB1");
9497  TH2F *recosignalVariance0HB1 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HB1");
9498  TH2F *recosignalVarianceHB1 = (TH2F *)recosignalVariance1HB1->Clone("recosignalVarianceHB1");
9499  recosignalVarianceHB1->Divide(recosignalVariance1HB1, recosignalVariance0HB1, 1, 1, "B");
9500  TH2F *recosignalVariance1HB2 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy2_HB2");
9501  TH2F *recosignalVariance0HB2 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HB2");
9502  TH2F *recosignalVarianceHB2 = (TH2F *)recosignalVariance1HB2->Clone("recosignalVarianceHB2");
9503  recosignalVarianceHB2->Divide(recosignalVariance1HB2, recosignalVariance0HB2, 1, 1, "B");
9504  TH2F *recosignalVariance1HB3 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy2_HB3");
9505  TH2F *recosignalVariance0HB3 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HB3");
9506  TH2F *recosignalVarianceHB3 = (TH2F *)recosignalVariance1HB3->Clone("recosignalVarianceHB3");
9507  recosignalVarianceHB3->Divide(recosignalVariance1HB3, recosignalVariance0HB3, 1, 1, "B");
9508  TH2F *recosignalVariance1HB4 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy2_HB4");
9509  TH2F *recosignalVariance0HB4 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HB4");
9510  TH2F *recosignalVarianceHB4 = (TH2F *)recosignalVariance1HB4->Clone("recosignalVarianceHB4");
9511  recosignalVarianceHB4->Divide(recosignalVariance1HB4, recosignalVariance0HB4, 1, 1, "B");
9512  //cout<<" Vaiance: preparation DONE *****" <<endl;
9513  //====================================================================== put Vaiance=Dispersia = Sig**2=<R**2> - (<R>)**2 into massive recosignalvarianceHB
9514  // = sum(R*R)/N - (sum(R)/N)**2
9515  for (int jeta = 0; jeta < njeta; jeta++) {
9516  //preparation for PHI normalization:
9517  double sumrecosignalHB0 = 0;
9518  int nsumrecosignalHB0 = 0;
9519  double sumrecosignalHB1 = 0;
9520  int nsumrecosignalHB1 = 0;
9521  double sumrecosignalHB2 = 0;
9522  int nsumrecosignalHB2 = 0;
9523  double sumrecosignalHB3 = 0;
9524  int nsumrecosignalHB3 = 0;
9525  for (int jphi = 0; jphi < njphi; jphi++) {
9526  recosignalvarianceHB[0][jeta][jphi] = recosignalVarianceHB1->GetBinContent(jeta + 1, jphi + 1);
9527  recosignalvarianceHB[1][jeta][jphi] = recosignalVarianceHB2->GetBinContent(jeta + 1, jphi + 1);
9528  recosignalvarianceHB[2][jeta][jphi] = recosignalVarianceHB3->GetBinContent(jeta + 1, jphi + 1);
9529  recosignalvarianceHB[3][jeta][jphi] = recosignalVarianceHB4->GetBinContent(jeta + 1, jphi + 1);
9530  if (recosignalvarianceHB[0][jeta][jphi] > 0.) {
9531  sumrecosignalHB0 += recosignalvarianceHB[0][jeta][jphi];
9532  ++nsumrecosignalHB0;
9533  }
9534  if (recosignalvarianceHB[1][jeta][jphi] > 0.) {
9535  sumrecosignalHB1 += recosignalvarianceHB[1][jeta][jphi];
9536  ++nsumrecosignalHB1;
9537  }
9538  if (recosignalvarianceHB[2][jeta][jphi] > 0.) {
9539  sumrecosignalHB2 += recosignalvarianceHB[2][jeta][jphi];
9540  ++nsumrecosignalHB2;
9541  }
9542  if (recosignalvarianceHB[3][jeta][jphi] > 0.) {
9543  sumrecosignalHB3 += recosignalvarianceHB[3][jeta][jphi];
9544  ++nsumrecosignalHB3;
9545  }
9546  } // phi
9547  // PHI normalization :
9548  for (int jphi = 0; jphi < njphi; jphi++) {
9549  if (recosignalvarianceHB[0][jeta][jphi] > 0.)
9550  recosignalvarianceHB[0][jeta][jphi] /= (sumrecosignalHB0 / nsumrecosignalHB0);
9551  if (recosignalvarianceHB[1][jeta][jphi] > 0.)
9552  recosignalvarianceHB[1][jeta][jphi] /= (sumrecosignalHB1 / nsumrecosignalHB1);
9553  if (recosignalvarianceHB[2][jeta][jphi] > 0.)
9554  recosignalvarianceHB[2][jeta][jphi] /= (sumrecosignalHB2 / nsumrecosignalHB2);
9555  if (recosignalvarianceHB[3][jeta][jphi] > 0.)
9556  recosignalvarianceHB[3][jeta][jphi] /= (sumrecosignalHB3 / nsumrecosignalHB3);
9557  } // phi
9558  // recosignalvarianceHB (D) = sum(R*R)/N - (sum(R)/N)**2
9559  for (int jphi = 0; jphi < njphi; jphi++) {
9560  // cout<<"12 12 12 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
9561  recosignalvarianceHB[0][jeta][jphi] -= arecosignalHB[0][jeta][jphi] * arecosignalHB[0][jeta][jphi];
9562  recosignalvarianceHB[0][jeta][jphi] = fabs(recosignalvarianceHB[0][jeta][jphi]);
9563  recosignalvarianceHB[1][jeta][jphi] -= arecosignalHB[1][jeta][jphi] * arecosignalHB[1][jeta][jphi];
9564  recosignalvarianceHB[1][jeta][jphi] = fabs(recosignalvarianceHB[1][jeta][jphi]);
9565  recosignalvarianceHB[2][jeta][jphi] -= arecosignalHB[2][jeta][jphi] * arecosignalHB[2][jeta][jphi];
9566  recosignalvarianceHB[2][jeta][jphi] = fabs(recosignalvarianceHB[2][jeta][jphi]);
9567  recosignalvarianceHB[3][jeta][jphi] -= arecosignalHB[3][jeta][jphi] * arecosignalHB[3][jeta][jphi];
9568  recosignalvarianceHB[3][jeta][jphi] = fabs(recosignalvarianceHB[3][jeta][jphi]);
9569  }
9570  }
9571  //cout<<" Vaiance: DONE*****" <<endl;
9572  //------------------------ 2D-eta/phi-plot: D, averaged over depthfs
9573  //======================================================================
9574  //======================================================================
9575  //cout<<" R2D-eta/phi-plot: D, averaged over depthfs *****" <<endl;
9576  c1x1->Clear();
9578  c1x0->Divide(1, 1);
9579  c1x0->cd(1);
9580  TH2F *DefzDrecosignalHB42D = new TH2F("DefzDrecosignalHB42D", "", neta, -41., 41., nphi, 0., 72.);
9581  TH2F *DefzDrecosignalHB42D0 = new TH2F("DefzDrecosignalHB42D0", "", neta, -41., 41., nphi, 0., 72.);
9582  TH2F *DefzDrecosignalHB42DF = (TH2F *)DefzDrecosignalHB42D0->Clone("DefzDrecosignalHB42DF");
9583  for (int i = 0; i < ndepth; i++) {
9584  for (int jeta = 0; jeta < neta; jeta++) {
9585  for (int jphi = 0; jphi < nphi; jphi++) {
9586  double ccc1 = recosignalvarianceHB[i][jeta][jphi];
9587  int k2plot = jeta - 41;
9588  int kkk = k2plot; //if(k2plot >0 kkk=k2plot+1; //-41 +41 !=0
9589  if (arecosignalHB[i][jeta][jphi] > 0.) {
9590  DefzDrecosignalHB42D->Fill(kkk, jphi, ccc1);
9591  DefzDrecosignalHB42D0->Fill(kkk, jphi, 1.);
9592  }
9593  }
9594  }
9595  }
9596  DefzDrecosignalHB42DF->Divide(DefzDrecosignalHB42D, DefzDrecosignalHB42D0, 1, 1, "B"); // average A
9597  // DefzDrecosignalHB1->Sumw2();
9598  gPad->SetGridy();
9599  gPad->SetGridx(); // gPad->SetLogz();
9600  DefzDrecosignalHB42DF->SetMarkerStyle(20);
9601  DefzDrecosignalHB42DF->SetMarkerSize(0.4);
9602  DefzDrecosignalHB42DF->GetZaxis()->SetLabelSize(0.08);
9603  DefzDrecosignalHB42DF->SetXTitle("<D>_depth #eta \b");
9604  DefzDrecosignalHB42DF->SetYTitle(" #phi \b");
9605  DefzDrecosignalHB42DF->SetZTitle("<D>_depth \b");
9606  DefzDrecosignalHB42DF->SetMarkerColor(2);
9607  DefzDrecosignalHB42DF->SetLineColor(
9608  0); // DefzDrecosignalHB42DF->SetMaximum(1.000); // DefzDrecosignalHB42DF->SetMinimum(1.0);
9609  DefzDrecosignalHB42DF->Draw("COLZ");
9611  c1x0->Update();
9612  c1x0->Print("DrecosignalGeneralD2PhiSymmetryHB.png");
9613  c1x0->Clear();
9614  // clean-up
9615  if (DefzDrecosignalHB42D)
9616  delete DefzDrecosignalHB42D;
9617  if (DefzDrecosignalHB42D0)
9618  delete DefzDrecosignalHB42D0;
9619  if (DefzDrecosignalHB42DF)
9620  delete DefzDrecosignalHB42DF;
9621  //====================================================================== 1D plot: D vs phi , averaged over depthfs & eta
9622  //======================================================================
9623  //cout<<" 1D plot: D vs phi , averaged over depthfs & eta *****" <<endl;
9624  c1x1->Clear();
9626  c1x1->Divide(1, 1);
9627  c1x1->cd(1);
9628  TH1F *DefzDrecosignalHB41D = new TH1F("DefzDrecosignalHB41D", "", nphi, 0., 72.);
9629  TH1F *DefzDrecosignalHB41D0 = new TH1F("DefzDrecosignalHB41D0", "", nphi, 0., 72.);
9630  TH1F *DefzDrecosignalHB41DF = (TH1F *)DefzDrecosignalHB41D0->Clone("DefzDrecosignalHB41DF");
9631 
9632  for (int jphi = 0; jphi < nphi; jphi++) {
9633  for (int jeta = 0; jeta < neta; jeta++) {
9634  for (int i = 0; i < ndepth; i++) {
9635  double ccc1 = recosignalvarianceHB[i][jeta][jphi];
9636  if (arecosignalHB[i][jeta][jphi] > 0.) {
9637  DefzDrecosignalHB41D->Fill(jphi, ccc1);
9638  DefzDrecosignalHB41D0->Fill(jphi, 1.);
9639  }
9640  }
9641  }
9642  }
9643  // DefzDrecosignalHB41D->Sumw2();DefzDrecosignalHB41D0->Sumw2();
9644 
9645  DefzDrecosignalHB41DF->Divide(
9646  DefzDrecosignalHB41D, DefzDrecosignalHB41D0, 1, 1, "B"); // R averaged over depthfs & eta
9647  DefzDrecosignalHB41D0->Sumw2();
9648  // for (int jphi=1;jphi<73;jphi++) {DefzDrecosignalHB41DF->SetBinError(jphi,0.01);}
9649  gPad->SetGridy();
9650  gPad->SetGridx(); // gPad->SetLogz();
9651  DefzDrecosignalHB41DF->SetMarkerStyle(20);
9652  DefzDrecosignalHB41DF->SetMarkerSize(1.4);
9653  DefzDrecosignalHB41DF->GetZaxis()->SetLabelSize(0.08);
9654  DefzDrecosignalHB41DF->SetXTitle("#phi \b");
9655  DefzDrecosignalHB41DF->SetYTitle(" <D> \b");
9656  DefzDrecosignalHB41DF->SetZTitle("<D>_PHI - AllDepthfs \b");
9657  DefzDrecosignalHB41DF->SetMarkerColor(4);
9658  DefzDrecosignalHB41DF->SetLineColor(
9659  4); // DefzDrecosignalHB41DF->SetMinimum(0.8); DefzDrecosignalHB41DF->SetMinimum(-0.015);
9660  DefzDrecosignalHB41DF->Draw("Error");
9662  c1x1->Update();
9663  c1x1->Print("DrecosignalGeneralD1PhiSymmetryHB.png");
9664  c1x1->Clear();
9665  // clean-up
9666  if (DefzDrecosignalHB41D)
9667  delete DefzDrecosignalHB41D;
9668  if (DefzDrecosignalHB41D0)
9669  delete DefzDrecosignalHB41D0;
9670  if (DefzDrecosignalHB41DF)
9671  delete DefzDrecosignalHB41DF;
9672 
9673  //========================================================================================== 14
9674  //======================================================================
9675  //======================================================================1D plot: D vs phi , different eta, depth=1
9676  //cout<<" 1D plot: D vs phi , different eta, depth=1 *****" <<endl;
9677  c3x5->Clear();
9679  c3x5->Divide(4, 4);
9680  c3x5->cd(1);
9681  int kcountHBpositivedirectionRecosignalD1 = 1;
9682  TH1F *h2CeffHBpositivedirectionRecosignalD1 = new TH1F("h2CeffHBpositivedirectionRecosignalD1", "", nphi, 0., 72.);
9683 
9684  for (int jeta = 0; jeta < njeta; jeta++) {
9685  // positivedirectionRecosignalD:
9686  if (jeta - 41 >= 0) {
9687  // for (int i=0;i<ndepth;i++) {
9688  // depth=1
9689  for (int i = 0; i < 1; i++) {
9690  TH1F *HBpositivedirectionRecosignalD1 = (TH1F *)h2CeffHBpositivedirectionRecosignalD1->Clone("twod1");
9691 
9692  float ccctest = 0; // to avoid empty massive elements
9693  for (int jphi = 0; jphi < nphi; jphi++) {
9694  double ccc1 = recosignalvarianceHB[i][jeta][jphi];
9695  if (arecosignalHB[i][jeta][jphi] > 0.) {
9696  HBpositivedirectionRecosignalD1->Fill(jphi, ccc1);
9697  ccctest = 1.; //HBpositivedirectionRecosignalD1->SetBinError(i,0.01);
9698  }
9699  } // for jphi
9700  if (ccctest > 0.) {
9701  //cout<<"1414 kcountHBpositivedirectionRecosignalD1 = "<<kcountHBpositivedirectionRecosignalD1 <<" jeta-41= "<< jeta-41 <<endl;
9702  c3x5->cd(kcountHBpositivedirectionRecosignalD1);
9703  HBpositivedirectionRecosignalD1->SetMarkerStyle(20);
9704  HBpositivedirectionRecosignalD1->SetMarkerSize(0.4);
9705  HBpositivedirectionRecosignalD1->GetYaxis()->SetLabelSize(0.04);
9706  HBpositivedirectionRecosignalD1->SetXTitle("HBpositivedirectionRecosignalD1 \b");
9707  HBpositivedirectionRecosignalD1->SetMarkerColor(2);
9708  HBpositivedirectionRecosignalD1->SetLineColor(0);
9709  gPad->SetGridy();
9710  gPad->SetGridx();
9711  // gPad->SetLogy();
9712  if (kcountHBpositivedirectionRecosignalD1 == 1)
9713  HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 0; depth = 1 \b");
9714  if (kcountHBpositivedirectionRecosignalD1 == 2)
9715  HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 1; depth = 1 \b");
9716  if (kcountHBpositivedirectionRecosignalD1 == 3)
9717  HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 2; depth = 1 \b");
9718  if (kcountHBpositivedirectionRecosignalD1 == 4)
9719  HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 3; depth = 1 \b");
9720  if (kcountHBpositivedirectionRecosignalD1 == 5)
9721  HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 4; depth = 1 \b");
9722  if (kcountHBpositivedirectionRecosignalD1 == 6)
9723  HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 5; depth = 1 \b");
9724  if (kcountHBpositivedirectionRecosignalD1 == 7)
9725  HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 6; depth = 1 \b");
9726  if (kcountHBpositivedirectionRecosignalD1 == 8)
9727  HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 7; depth = 1 \b");
9728  if (kcountHBpositivedirectionRecosignalD1 == 9)
9729  HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 8; depth = 1 \b");
9730  if (kcountHBpositivedirectionRecosignalD1 == 10)
9731  HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 9; depth = 1 \b");
9732  if (kcountHBpositivedirectionRecosignalD1 == 11)
9733  HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 10; depth = 1 \b");
9734  if (kcountHBpositivedirectionRecosignalD1 == 12)
9735  HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 11; depth = 1 \b");
9736  if (kcountHBpositivedirectionRecosignalD1 == 13)
9737  HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 12; depth = 1 \b");
9738  if (kcountHBpositivedirectionRecosignalD1 == 14)
9739  HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 13; depth = 1 \b");
9740  if (kcountHBpositivedirectionRecosignalD1 == 15)
9741  HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 14; depth = 1 \b");
9742  if (kcountHBpositivedirectionRecosignalD1 == 16)
9743  HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 15; depth = 1 \b");
9744  HBpositivedirectionRecosignalD1->Draw("Error");
9745  kcountHBpositivedirectionRecosignalD1++;
9746  if (kcountHBpositivedirectionRecosignalD1 > 16)
9747  break; // 4x6 = 24
9748  } //ccctest>0
9749 
9750  } // for i
9751  } //if(jeta-41 >= 0)
9752  } //for jeta
9754  c3x5->Update();
9755  c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth1HB.png");
9756  c3x5->Clear();
9757  // clean-up
9758  if (h2CeffHBpositivedirectionRecosignalD1)
9759  delete h2CeffHBpositivedirectionRecosignalD1;
9760  //========================================================================================== 15
9761  //======================================================================
9762  //======================================================================1D plot: D vs phi , different eta, depth=2
9763  //cout<<" 1D plot: D vs phi , different eta, depth=2 *****" <<endl;
9764  c3x5->Clear();
9765  c3x5->Divide(4, 4);
9766  c3x5->cd(1);
9767  int kcountHBpositivedirectionRecosignalD2 = 1;
9768  TH1F *h2CeffHBpositivedirectionRecosignalD2 = new TH1F("h2CeffHBpositivedirectionRecosignalD2", "", nphi, 0., 72.);
9769 
9770  for (int jeta = 0; jeta < njeta; jeta++) {
9771  // positivedirectionRecosignalD:
9772  if (jeta - 41 >= 0) {
9773  // for (int i=0;i<ndepth;i++) {
9774  // depth=2
9775  for (int i = 1; i < 2; i++) {
9776  TH1F *HBpositivedirectionRecosignalD2 = (TH1F *)h2CeffHBpositivedirectionRecosignalD2->Clone("twod1");
9777 
9778  float ccctest = 0; // to avoid empty massive elements
9779  for (int jphi = 0; jphi < nphi; jphi++) {
9780  double ccc1 = recosignalvarianceHB[i][jeta][jphi];
9781  if (arecosignalHB[i][jeta][jphi] > 0.) {
9782  HBpositivedirectionRecosignalD2->Fill(jphi, ccc1);
9783  ccctest = 1.; //HBpositivedirectionRecosignalD2->SetBinError(i,0.01);
9784  }
9785  } // for jphi
9786  if (ccctest > 0.) {
9787  //cout<<"1515 kcountHBpositivedirectionRecosignalD2 = "<<kcountHBpositivedirectionRecosignalD2 <<" jeta-41= "<< jeta-41 <<endl;
9788  c3x5->cd(kcountHBpositivedirectionRecosignalD2);
9789  HBpositivedirectionRecosignalD2->SetMarkerStyle(20);
9790  HBpositivedirectionRecosignalD2->SetMarkerSize(0.4);
9791  HBpositivedirectionRecosignalD2->GetYaxis()->SetLabelSize(0.04);
9792  HBpositivedirectionRecosignalD2->SetXTitle("HBpositivedirectionRecosignalD2 \b");
9793  HBpositivedirectionRecosignalD2->SetMarkerColor(2);
9794  HBpositivedirectionRecosignalD2->SetLineColor(0);
9795  gPad->SetGridy();
9796  gPad->SetGridx();
9797  // gPad->SetLogy();
9798  if (kcountHBpositivedirectionRecosignalD2 == 1)
9799  HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 0; depth = 2 \b");
9800  if (kcountHBpositivedirectionRecosignalD2 == 2)
9801  HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 1; depth = 2 \b");
9802  if (kcountHBpositivedirectionRecosignalD2 == 3)
9803  HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 2; depth = 2 \b");
9804  if (kcountHBpositivedirectionRecosignalD2 == 4)
9805  HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 3; depth = 2 \b");
9806  if (kcountHBpositivedirectionRecosignalD2 == 5)
9807  HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 4; depth = 2 \b");
9808  if (kcountHBpositivedirectionRecosignalD2 == 6)
9809  HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 5; depth = 2 \b");
9810  if (kcountHBpositivedirectionRecosignalD2 == 7)
9811  HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 6; depth = 2 \b");
9812  if (kcountHBpositivedirectionRecosignalD2 == 8)
9813  HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 7; depth = 2 \b");
9814  if (kcountHBpositivedirectionRecosignalD2 == 9)
9815  HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 8; depth = 2 \b");
9816  if (kcountHBpositivedirectionRecosignalD2 == 10)
9817  HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 9; depth = 2 \b");
9818  if (kcountHBpositivedirectionRecosignalD2 == 11)
9819  HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 10; depth = 2 \b");
9820  if (kcountHBpositivedirectionRecosignalD2 == 12)
9821  HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 11; depth = 2 \b");
9822  if (kcountHBpositivedirectionRecosignalD2 == 13)
9823  HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 12; depth = 2 \b");
9824  if (kcountHBpositivedirectionRecosignalD2 == 14)
9825  HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 13; depth = 2 \b");
9826  if (kcountHBpositivedirectionRecosignalD2 == 15)
9827  HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 14; depth = 2 \b");
9828  if (kcountHBpositivedirectionRecosignalD2 == 16)
9829  HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 15; depth = 2 \b");
9830  HBpositivedirectionRecosignalD2->Draw("Error");
9831  kcountHBpositivedirectionRecosignalD2++;
9832  if (kcountHBpositivedirectionRecosignalD2 > 16)
9833  break; // 4x6 = 24
9834  } //ccctest>0
9835 
9836  } // for i
9837  } //if(jeta-41 >= 0)
9838  } //for jeta
9840  c3x5->Update();
9841  c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth2HB.png");
9842  c3x5->Clear();
9843  // clean-up
9844  if (h2CeffHBpositivedirectionRecosignalD2)
9845  delete h2CeffHBpositivedirectionRecosignalD2;
9846  //========================================================================================== 16
9847  //======================================================================
9848  //======================================================================1D plot: D vs phi , different eta, depth=3
9849  //cout<<" 1D plot: D vs phi , different eta, depth=3 *****" <<endl;
9850  c3x5->Clear();
9851  c3x5->Divide(4, 4);
9852  c3x5->cd(1);
9853  int kcountHBpositivedirectionRecosignalD3 = 1;
9854  TH1F *h2CeffHBpositivedirectionRecosignalD3 = new TH1F("h2CeffHBpositivedirectionRecosignalD3", "", nphi, 0., 72.);
9855 
9856  for (int jeta = 0; jeta < njeta; jeta++) {
9857  // positivedirectionRecosignalD:
9858  if (jeta - 41 >= 0) {
9859  // for (int i=0;i<ndepth;i++) {
9860  // depth=3
9861  for (int i = 2; i < 3; i++) {
9862  TH1F *HBpositivedirectionRecosignalD3 = (TH1F *)h2CeffHBpositivedirectionRecosignalD3->Clone("twod1");
9863 
9864  float ccctest = 0; // to avoid empty massive elements
9865  for (int jphi = 0; jphi < nphi; jphi++) {
9866  double ccc1 = recosignalvarianceHB[i][jeta][jphi];
9867  if (arecosignalHB[i][jeta][jphi] > 0.) {
9868  HBpositivedirectionRecosignalD3->Fill(jphi, ccc1);
9869  ccctest = 1.; //HBpositivedirectionRecosignalD3->SetBinError(i,0.01);
9870  }
9871  } // for jphi
9872  if (ccctest > 0.) {
9873  //cout<<"1616 kcountHBpositivedirectionRecosignalD3 = "<<kcountHBpositivedirectionRecosignalD3 <<" jeta-41= "<< jeta-41 <<endl;
9874  c3x5->cd(kcountHBpositivedirectionRecosignalD3);
9875  HBpositivedirectionRecosignalD3->SetMarkerStyle(20);
9876  HBpositivedirectionRecosignalD3->SetMarkerSize(0.4);
9877  HBpositivedirectionRecosignalD3->GetYaxis()->SetLabelSize(0.04);
9878  HBpositivedirectionRecosignalD3->SetXTitle("HBpositivedirectionRecosignalD3 \b");
9879  HBpositivedirectionRecosignalD3->SetMarkerColor(2);
9880  HBpositivedirectionRecosignalD3->SetLineColor(0);
9881  gPad->SetGridy();
9882  gPad->SetGridx();
9883  // gPad->SetLogy();
9884  if (kcountHBpositivedirectionRecosignalD3 == 1)
9885  HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 0; depth = 3 \b");
9886  if (kcountHBpositivedirectionRecosignalD3 == 2)
9887  HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 1; depth = 3 \b");
9888  if (kcountHBpositivedirectionRecosignalD3 == 3)
9889  HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 2; depth = 3 \b");
9890  if (kcountHBpositivedirectionRecosignalD3 == 4)
9891  HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 3; depth = 3 \b");
9892  if (kcountHBpositivedirectionRecosignalD3 == 5)
9893  HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 4; depth = 3 \b");
9894  if (kcountHBpositivedirectionRecosignalD3 == 6)
9895  HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 5; depth = 3 \b");
9896  if (kcountHBpositivedirectionRecosignalD3 == 7)
9897  HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 6; depth = 3 \b");
9898  if (kcountHBpositivedirectionRecosignalD3 == 8)
9899  HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 7; depth = 3 \b");
9900  if (kcountHBpositivedirectionRecosignalD3 == 9)
9901  HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 8; depth = 3 \b");
9902  if (kcountHBpositivedirectionRecosignalD3 == 10)
9903  HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 9; depth = 3 \b");
9904  if (kcountHBpositivedirectionRecosignalD3 == 11)
9905  HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 10; depth = 3 \b");
9906  if (kcountHBpositivedirectionRecosignalD3 == 12)
9907  HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 11; depth = 3 \b");
9908  if (kcountHBpositivedirectionRecosignalD3 == 13)
9909  HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 12; depth = 3 \b");
9910  if (kcountHBpositivedirectionRecosignalD3 == 14)
9911  HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 13; depth = 3 \b");
9912  if (kcountHBpositivedirectionRecosignalD3 == 15)
9913  HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 14; depth = 3 \b");
9914  if (kcountHBpositivedirectionRecosignalD3 == 16)
9915  HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 15; depth = 3 \b");
9916  HBpositivedirectionRecosignalD3->Draw("Error");
9917  kcountHBpositivedirectionRecosignalD3++;
9918  if (kcountHBpositivedirectionRecosignalD3 > 16)
9919  break; // 4x6 = 24
9920  } //ccctest>0
9921 
9922  } // for i
9923  } //if(jeta-41 >= 0)
9924  } //for jeta
9926  c3x5->Update();
9927  c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth3HB.png");
9928  c3x5->Clear();
9929  // clean-up
9930  if (h2CeffHBpositivedirectionRecosignalD3)
9931  delete h2CeffHBpositivedirectionRecosignalD3;
9932  //========================================================================================== 17
9933  //======================================================================
9934  //======================================================================1D plot: D vs phi , different eta, depth=4
9935  //cout<<" 1D plot: D vs phi , different eta, depth=4 *****" <<endl;
9936  c3x5->Clear();
9937  c3x5->Divide(4, 4);
9938  c3x5->cd(1);
9939  int kcountHBpositivedirectionRecosignalD4 = 1;
9940  TH1F *h2CeffHBpositivedirectionRecosignalD4 = new TH1F("h2CeffHBpositivedirectionRecosignalD4", "", nphi, 0., 72.);
9941 
9942  for (int jeta = 0; jeta < njeta; jeta++) {
9943  // positivedirectionRecosignalD:
9944  if (jeta - 41 >= 0) {
9945  // for (int i=0;i<ndepth;i++) {
9946  // depth=4
9947  for (int i = 3; i < 4; i++) {
9948  TH1F *HBpositivedirectionRecosignalD4 = (TH1F *)h2CeffHBpositivedirectionRecosignalD4->Clone("twod1");
9949 
9950  float ccctest = 0; // to avoid empty massive elements
9951  for (int jphi = 0; jphi < nphi; jphi++) {
9952  double ccc1 = recosignalvarianceHB[i][jeta][jphi];
9953  if (arecosignalHB[i][jeta][jphi] > 0.) {
9954  HBpositivedirectionRecosignalD4->Fill(jphi, ccc1);
9955  ccctest = 1.; //HBpositivedirectionRecosignalD4->SetBinError(i,0.01);
9956  }
9957  } // for jphi
9958  if (ccctest > 0.) {
9959  //cout<<"1717 kcountHBpositivedirectionRecosignalD4 = "<<kcountHBpositivedirectionRecosignalD4 <<" jeta-41= "<< jeta-41 <<endl;
9960  c3x5->cd(kcountHBpositivedirectionRecosignalD4);
9961  HBpositivedirectionRecosignalD4->SetMarkerStyle(20);
9962  HBpositivedirectionRecosignalD4->SetMarkerSize(0.4);
9963  HBpositivedirectionRecosignalD4->GetYaxis()->SetLabelSize(0.04);
9964  HBpositivedirectionRecosignalD4->SetXTitle("HBpositivedirectionRecosignalD4 \b");
9965  HBpositivedirectionRecosignalD4->SetMarkerColor(2);
9966  HBpositivedirectionRecosignalD4->SetLineColor(0);
9967  gPad->SetGridy();
9968  gPad->SetGridx();
9969  // gPad->SetLogy();
9970  if (kcountHBpositivedirectionRecosignalD4 == 1)
9971  HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 0; depth = 4 \b");
9972  if (kcountHBpositivedirectionRecosignalD4 == 2)
9973  HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 1; depth = 4 \b");
9974  if (kcountHBpositivedirectionRecosignalD4 == 3)
9975  HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 2; depth = 4 \b");
9976  if (kcountHBpositivedirectionRecosignalD4 == 4)
9977  HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 3; depth = 4 \b");
9978  if (kcountHBpositivedirectionRecosignalD4 == 5)
9979  HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 4; depth = 4 \b");
9980  if (kcountHBpositivedirectionRecosignalD4 == 6)
9981  HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 5; depth = 4 \b");
9982  if (kcountHBpositivedirectionRecosignalD4 == 7)
9983  HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 6; depth = 4 \b");
9984  if (kcountHBpositivedirectionRecosignalD4 == 8)
9985  HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 7; depth = 4 \b");
9986  if (kcountHBpositivedirectionRecosignalD4 == 9)
9987  HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 8; depth = 4 \b");
9988  if (kcountHBpositivedirectionRecosignalD4 == 10)
9989  HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 9; depth = 4 \b");
9990  if (kcountHBpositivedirectionRecosignalD4 == 11)
9991  HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 10; depth = 4 \b");
9992  if (kcountHBpositivedirectionRecosignalD4 == 12)
9993  HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 11; depth = 4 \b");
9994  if (kcountHBpositivedirectionRecosignalD4 == 13)
9995  HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 12; depth = 4 \b");
9996  if (kcountHBpositivedirectionRecosignalD4 == 14)
9997  HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 13; depth = 4 \b");
9998  if (kcountHBpositivedirectionRecosignalD4 == 15)
9999  HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 14; depth = 4 \b");
10000  if (kcountHBpositivedirectionRecosignalD4 == 16)
10001  HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 15; depth = 4 \b");
10002  HBpositivedirectionRecosignalD4->Draw("Error");
10003  kcountHBpositivedirectionRecosignalD4++;
10004  if (kcountHBpositivedirectionRecosignalD4 > 16)
10005  break; // 4x6 = 24
10006  } //ccctest>0
10007 
10008  } // for i
10009  } //if(jeta-41 >= 0)
10010  } //for jeta
10012  c3x5->Update();
10013  c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth4HB.png");
10014  c3x5->Clear();
10015  // clean-up
10016  if (h2CeffHBpositivedirectionRecosignalD4)
10017  delete h2CeffHBpositivedirectionRecosignalD4;
10018 
10019  //========================================================================================== 22214
10020  //======================================================================
10021  //======================================================================1D plot: D vs phi , different eta, depth=1
10022  //cout<<" 1D plot: D vs phi , different eta, depth=1 *****" <<endl;
10023  c3x5->Clear();
10025  c3x5->Divide(4, 4);
10026  c3x5->cd(1);
10027  int kcountHBnegativedirectionRecosignalD1 = 1;
10028  TH1F *h2CeffHBnegativedirectionRecosignalD1 = new TH1F("h2CeffHBnegativedirectionRecosignalD1", "", nphi, 0., 72.);
10029 
10030  for (int jeta = 0; jeta < njeta; jeta++) {
10031  // negativedirectionRecosignalD:
10032  if (jeta - 41 < 0) {
10033  // for (int i=0;i<ndepth;i++) {
10034  // depth=1
10035  for (int i = 0; i < 1; i++) {
10036  TH1F *HBnegativedirectionRecosignalD1 = (TH1F *)h2CeffHBnegativedirectionRecosignalD1->Clone("twod1");
10037 
10038  float ccctest = 0; // to avoid empty massive elements
10039  for (int jphi = 0; jphi < nphi; jphi++) {
10040  double ccc1 = recosignalvarianceHB[i][jeta][jphi];
10041  if (arecosignalHB[i][jeta][jphi] > 0.) {
10042  HBnegativedirectionRecosignalD1->Fill(jphi, ccc1);
10043  ccctest = 1.; //HBnegativedirectionRecosignalD1->SetBinError(i,0.01);
10044  }
10045  } // for jphi
10046  if (ccctest > 0.) {
10047  //cout<<"1414 kcountHBnegativedirectionRecosignalD1 = "<<kcountHBnegativedirectionRecosignalD1 <<" jeta-41= "<< jeta-41 <<endl;
10048  c3x5->cd(kcountHBnegativedirectionRecosignalD1);
10049  HBnegativedirectionRecosignalD1->SetMarkerStyle(20);
10050  HBnegativedirectionRecosignalD1->SetMarkerSize(0.4);
10051  HBnegativedirectionRecosignalD1->GetYaxis()->SetLabelSize(0.04);
10052  HBnegativedirectionRecosignalD1->SetXTitle("HBnegativedirectionRecosignalD1 \b");
10053  HBnegativedirectionRecosignalD1->SetMarkerColor(2);
10054  HBnegativedirectionRecosignalD1->SetLineColor(0);
10055  gPad->SetGridy();
10056  gPad->SetGridx();
10057  // gPad->SetLogy();
10058  if (kcountHBnegativedirectionRecosignalD1 == 1)
10059  HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -16; depth = 1 \b");
10060  if (kcountHBnegativedirectionRecosignalD1 == 2)
10061  HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -15; depth = 1 \b");
10062  if (kcountHBnegativedirectionRecosignalD1 == 3)
10063  HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -14; depth = 1 \b");
10064  if (kcountHBnegativedirectionRecosignalD1 == 4)
10065  HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -13; depth = 1 \b");
10066  if (kcountHBnegativedirectionRecosignalD1 == 5)
10067  HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -12; depth = 1 \b");
10068  if (kcountHBnegativedirectionRecosignalD1 == 6)
10069  HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -11; depth = 1 \b");
10070  if (kcountHBnegativedirectionRecosignalD1 == 7)
10071  HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -10; depth = 1 \b");
10072  if (kcountHBnegativedirectionRecosignalD1 == 8)
10073  HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -9; depth = 1 \b");
10074  if (kcountHBnegativedirectionRecosignalD1 == 9)
10075  HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -8; depth = 1 \b");
10076  if (kcountHBnegativedirectionRecosignalD1 == 10)
10077  HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -7; depth = 1 \b");
10078  if (kcountHBnegativedirectionRecosignalD1 == 11)
10079  HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -6; depth = 1 \b");
10080  if (kcountHBnegativedirectionRecosignalD1 == 12)
10081  HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -5; depth = 1 \b");
10082  if (kcountHBnegativedirectionRecosignalD1 == 13)
10083  HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -4; depth = 1 \b");
10084  if (kcountHBnegativedirectionRecosignalD1 == 14)
10085  HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -3; depth = 1 \b");
10086  if (kcountHBnegativedirectionRecosignalD1 == 15)
10087  HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -2; depth = 1 \b");
10088  if (kcountHBnegativedirectionRecosignalD1 == 16)
10089  HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -1; depth = 1 \b");
10090  HBnegativedirectionRecosignalD1->Draw("Error");
10091  kcountHBnegativedirectionRecosignalD1++;
10092  if (kcountHBnegativedirectionRecosignalD1 > 16)
10093  break; // 4x6 = 24
10094  } //ccctest>0
10095 
10096  } // for i
10097  } //if(jeta-41 < 0)
10098  } //for jeta
10100  c3x5->Update();
10101  c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth1HB.png");
10102  c3x5->Clear();
10103  // clean-up
10104  if (h2CeffHBnegativedirectionRecosignalD1)
10105  delete h2CeffHBnegativedirectionRecosignalD1;
10106  //========================================================================================== 22215
10107  //======================================================================
10108  //======================================================================1D plot: D vs phi , different eta, depth=2
10109  //cout<<" 1D plot: D vs phi , different eta, depth=2 *****" <<endl;
10110  c3x5->Clear();
10111  c3x5->Divide(4, 4);
10112  c3x5->cd(1);
10113  int kcountHBnegativedirectionRecosignalD2 = 1;
10114  TH1F *h2CeffHBnegativedirectionRecosignalD2 = new TH1F("h2CeffHBnegativedirectionRecosignalD2", "", nphi, 0., 72.);
10115 
10116  for (int jeta = 0; jeta < njeta; jeta++) {
10117  // negativedirectionRecosignalD:
10118  if (jeta - 41 < 0) {
10119  // for (int i=0;i<ndepth;i++) {
10120  // depth=2
10121  for (int i = 1; i < 2; i++) {
10122  TH1F *HBnegativedirectionRecosignalD2 = (TH1F *)h2CeffHBnegativedirectionRecosignalD2->Clone("twod1");
10123 
10124  float ccctest = 0; // to avoid empty massive elements
10125  for (int jphi = 0; jphi < nphi; jphi++) {
10126  double ccc1 = recosignalvarianceHB[i][jeta][jphi];
10127  if (arecosignalHB[i][jeta][jphi] > 0.) {
10128  HBnegativedirectionRecosignalD2->Fill(jphi, ccc1);
10129  ccctest = 1.; //HBnegativedirectionRecosignalD2->SetBinError(i,0.01);
10130  }
10131  } // for jphi
10132  if (ccctest > 0.) {
10133  //cout<<"1515 kcountHBnegativedirectionRecosignalD2 = "<<kcountHBnegativedirectionRecosignalD2 <<" jeta-41= "<< jeta-41 <<endl;
10134  c3x5->cd(kcountHBnegativedirectionRecosignalD2);
10135  HBnegativedirectionRecosignalD2->SetMarkerStyle(20);
10136  HBnegativedirectionRecosignalD2->SetMarkerSize(0.4);
10137  HBnegativedirectionRecosignalD2->GetYaxis()->SetLabelSize(0.04);
10138  HBnegativedirectionRecosignalD2->SetXTitle("HBnegativedirectionRecosignalD2 \b");
10139  HBnegativedirectionRecosignalD2->SetMarkerColor(2);
10140  HBnegativedirectionRecosignalD2->SetLineColor(0);
10141  gPad->SetGridy();
10142  gPad->SetGridx();
10143  // gPad->SetLogy();
10144  if (kcountHBnegativedirectionRecosignalD2 == 1)
10145  HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-16; depth = 2 \b");
10146  if (kcountHBnegativedirectionRecosignalD2 == 2)
10147  HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-15; depth = 2 \b");
10148  if (kcountHBnegativedirectionRecosignalD2 == 3)
10149  HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-14; depth = 2 \b");
10150  if (kcountHBnegativedirectionRecosignalD2 == 4)
10151  HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-13; depth = 2 \b");
10152  if (kcountHBnegativedirectionRecosignalD2 == 5)
10153  HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-12; depth = 2 \b");
10154  if (kcountHBnegativedirectionRecosignalD2 == 6)
10155  HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-11; depth = 2 \b");
10156  if (kcountHBnegativedirectionRecosignalD2 == 7)
10157  HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-10; depth = 2 \b");
10158  if (kcountHBnegativedirectionRecosignalD2 == 8)
10159  HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-9 ; depth = 2 \b");
10160  if (kcountHBnegativedirectionRecosignalD2 == 9)
10161  HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-8 ; depth = 2 \b");
10162  if (kcountHBnegativedirectionRecosignalD2 == 10)
10163  HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-7 ; depth = 2 \b");
10164  if (kcountHBnegativedirectionRecosignalD2 == 11)
10165  HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-6 ; depth = 2 \b");
10166  if (kcountHBnegativedirectionRecosignalD2 == 12)
10167  HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-5 ; depth = 2 \b");
10168  if (kcountHBnegativedirectionRecosignalD2 == 13)
10169  HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-4 ; depth = 2 \b");
10170  if (kcountHBnegativedirectionRecosignalD2 == 14)
10171  HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-3 ; depth = 2 \b");
10172  if (kcountHBnegativedirectionRecosignalD2 == 15)
10173  HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-2 ; depth = 2 \b");
10174  if (kcountHBnegativedirectionRecosignalD2 == 16)
10175  HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-1 ; depth = 2 \b");
10176  HBnegativedirectionRecosignalD2->Draw("Error");
10177  kcountHBnegativedirectionRecosignalD2++;
10178  if (kcountHBnegativedirectionRecosignalD2 > 16)
10179  break; // 4x6 = 24
10180  } //ccctest>0
10181 
10182  } // for i
10183  } //if(jeta-41 < 0)
10184  } //for jeta
10186  c3x5->Update();
10187  c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth2HB.png");
10188  c3x5->Clear();
10189  // clean-up
10190  if (h2CeffHBnegativedirectionRecosignalD2)
10191  delete h2CeffHBnegativedirectionRecosignalD2;
10192  //========================================================================================== 22216
10193  //======================================================================
10194  //======================================================================1D plot: D vs phi , different eta, depth=3
10195  //cout<<" 1D plot: D vs phi , different eta, depth=3 *****" <<endl;
10196  c3x5->Clear();
10197  c3x5->Divide(4, 4);
10198  c3x5->cd(1);
10199  int kcountHBnegativedirectionRecosignalD3 = 1;
10200  TH1F *h2CeffHBnegativedirectionRecosignalD3 = new TH1F("h2CeffHBnegativedirectionRecosignalD3", "", nphi, 0., 72.);
10201 
10202  for (int jeta = 0; jeta < njeta; jeta++) {
10203  // negativedirectionRecosignalD:
10204  if (jeta - 41 < 0) {
10205  // for (int i=0;i<ndepth;i++) {
10206  // depth=3
10207  for (int i = 2; i < 3; i++) {
10208  TH1F *HBnegativedirectionRecosignalD3 = (TH1F *)h2CeffHBnegativedirectionRecosignalD3->Clone("twod1");
10209 
10210  float ccctest = 0; // to avoid empty massive elements
10211  for (int jphi = 0; jphi < nphi; jphi++) {
10212  double ccc1 = recosignalvarianceHB[i][jeta][jphi];
10213  if (arecosignalHB[i][jeta][jphi] > 0.) {
10214  HBnegativedirectionRecosignalD3->Fill(jphi, ccc1);
10215  ccctest = 1.; //HBnegativedirectionRecosignalD3->SetBinError(i,0.01);
10216  }
10217  } // for jphi
10218  if (ccctest > 0.) {
10219  //cout<<"1616 kcountHBnegativedirectionRecosignalD3 = "<<kcountHBnegativedirectionRecosignalD3 <<" jeta-41= "<< jeta-41 <<endl;
10220  c3x5->cd(kcountHBnegativedirectionRecosignalD3);
10221  HBnegativedirectionRecosignalD3->SetMarkerStyle(20);
10222  HBnegativedirectionRecosignalD3->SetMarkerSize(0.4);
10223  HBnegativedirectionRecosignalD3->GetYaxis()->SetLabelSize(0.04);
10224  HBnegativedirectionRecosignalD3->SetXTitle("HBnegativedirectionRecosignalD3 \b");
10225  HBnegativedirectionRecosignalD3->SetMarkerColor(2);
10226  HBnegativedirectionRecosignalD3->SetLineColor(0);
10227  gPad->SetGridy();
10228  gPad->SetGridx();
10229  // gPad->SetLogy();
10230  if (kcountHBnegativedirectionRecosignalD3 == 1)
10231  HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-16; depth = 3 \b");
10232  if (kcountHBnegativedirectionRecosignalD3 == 2)
10233  HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-15; depth = 3 \b");
10234  if (kcountHBnegativedirectionRecosignalD3 == 3)
10235  HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-14; depth = 3 \b");
10236  if (kcountHBnegativedirectionRecosignalD3 == 4)
10237  HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-13; depth = 3 \b");
10238  if (kcountHBnegativedirectionRecosignalD3 == 5)
10239  HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-12; depth = 3 \b");
10240  if (kcountHBnegativedirectionRecosignalD3 == 6)
10241  HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-11; depth = 3 \b");
10242  if (kcountHBnegativedirectionRecosignalD3 == 7)
10243  HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-10; depth = 3 \b");
10244  if (kcountHBnegativedirectionRecosignalD3 == 8)
10245  HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-9 ; depth = 3 \b");
10246  if (kcountHBnegativedirectionRecosignalD3 == 9)
10247  HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-8 ; depth = 3 \b");
10248  if (kcountHBnegativedirectionRecosignalD3 == 10)
10249  HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-7 ; depth = 3 \b");
10250  if (kcountHBnegativedirectionRecosignalD3 == 11)
10251  HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-6 ; depth = 3 \b");
10252  if (kcountHBnegativedirectionRecosignalD3 == 12)
10253  HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-5 ; depth = 3 \b");
10254  if (kcountHBnegativedirectionRecosignalD3 == 13)
10255  HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-4 ; depth = 3 \b");
10256  if (kcountHBnegativedirectionRecosignalD3 == 14)
10257  HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-3 ; depth = 3 \b");
10258  if (kcountHBnegativedirectionRecosignalD3 == 15)
10259  HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-2 ; depth = 3 \b");
10260  if (kcountHBnegativedirectionRecosignalD3 == 16)
10261  HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-1 ; depth = 3 \b");
10262  HBnegativedirectionRecosignalD3->Draw("Error");
10263  kcountHBnegativedirectionRecosignalD3++;
10264  if (kcountHBnegativedirectionRecosignalD3 > 16)
10265  break; // 4x6 = 24
10266  } //ccctest>0
10267 
10268  } // for i
10269  } //if(jeta-41 < 0)
10270  } //for jeta
10272  c3x5->Update();
10273  c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth3HB.png");
10274  c3x5->Clear();
10275  // clean-up
10276  if (h2CeffHBnegativedirectionRecosignalD3)
10277  delete h2CeffHBnegativedirectionRecosignalD3;
10278  //========================================================================================== 22217
10279  //======================================================================
10280  //======================================================================1D plot: D vs phi , different eta, depth=4
10281  //cout<<" 1D plot: D vs phi , different eta, depth=4 *****" <<endl;
10282  c3x5->Clear();
10283  c3x5->Divide(4, 4);
10284  c3x5->cd(1);
10285  int kcountHBnegativedirectionRecosignalD4 = 1;
10286  TH1F *h2CeffHBnegativedirectionRecosignalD4 = new TH1F("h2CeffHBnegativedirectionRecosignalD4", "", nphi, 0., 72.);
10287 
10288  for (int jeta = 0; jeta < njeta; jeta++) {
10289  // negativedirectionRecosignalD:
10290  if (jeta - 41 < 0) {
10291  // for (int i=0;i<ndepth;i++) {
10292  // depth=4
10293  for (int i = 3; i < 4; i++) {
10294  TH1F *HBnegativedirectionRecosignalD4 = (TH1F *)h2CeffHBnegativedirectionRecosignalD4->Clone("twod1");
10295 
10296  float ccctest = 0; // to avoid empty massive elements
10297  for (int jphi = 0; jphi < nphi; jphi++) {
10298  double ccc1 = recosignalvarianceHB[i][jeta][jphi];
10299  if (arecosignalHB[i][jeta][jphi] > 0.) {
10300  HBnegativedirectionRecosignalD4->Fill(jphi, ccc1);
10301  ccctest = 1.; //HBnegativedirectionRecosignalD4->SetBinError(i,0.01);
10302  }
10303  } // for jphi
10304  if (ccctest > 0.) {
10305  //cout<<"1717 kcountHBnegativedirectionRecosignalD4 = "<<kcountHBnegativedirectionRecosignalD4 <<" jeta-41= "<< jeta-41 <<endl;
10306  c3x5->cd(kcountHBnegativedirectionRecosignalD4);
10307  HBnegativedirectionRecosignalD4->SetMarkerStyle(20);
10308  HBnegativedirectionRecosignalD4->SetMarkerSize(0.4);
10309  HBnegativedirectionRecosignalD4->GetYaxis()->SetLabelSize(0.04);
10310  HBnegativedirectionRecosignalD4->SetXTitle("HBnegativedirectionRecosignalD4 \b");
10311  HBnegativedirectionRecosignalD4->SetMarkerColor(2);
10312  HBnegativedirectionRecosignalD4->SetLineColor(0);
10313  gPad->SetGridy();
10314  gPad->SetGridx();
10315  // gPad->SetLogy();
10316  if (kcountHBnegativedirectionRecosignalD4 == 1)
10317  HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-16; depth = 4 \b");
10318  if (kcountHBnegativedirectionRecosignalD4 == 2)
10319  HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-15; depth = 4 \b");
10320  if (kcountHBnegativedirectionRecosignalD4 == 3)
10321  HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-14; depth = 4 \b");
10322  if (kcountHBnegativedirectionRecosignalD4 == 4)
10323  HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-13; depth = 4 \b");
10324  if (kcountHBnegativedirectionRecosignalD4 == 5)
10325  HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-12; depth = 4 \b");
10326  if (kcountHBnegativedirectionRecosignalD4 == 6)
10327  HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-11; depth = 4 \b");
10328  if (kcountHBnegativedirectionRecosignalD4 == 7)
10329  HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-10; depth = 4 \b");
10330  if (kcountHBnegativedirectionRecosignalD4 == 8)
10331  HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-9 ; depth = 4 \b");
10332  if (kcountHBnegativedirectionRecosignalD4 == 9)
10333  HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-8 ; depth = 4 \b");
10334  if (kcountHBnegativedirectionRecosignalD4 == 10)
10335  HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-7 ; depth = 4 \b");
10336  if (kcountHBnegativedirectionRecosignalD4 == 11)
10337  HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-6 ; depth = 4 \b");
10338  if (kcountHBnegativedirectionRecosignalD4 == 12)
10339  HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-5 ; depth = 4 \b");
10340  if (kcountHBnegativedirectionRecosignalD4 == 13)
10341  HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-4 ; depth = 4 \b");
10342  if (kcountHBnegativedirectionRecosignalD4 == 14)
10343  HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-3 ; depth = 4 \b");
10344  if (kcountHBnegativedirectionRecosignalD4 == 15)
10345  HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-2 ; depth = 4 \b");
10346  if (kcountHBnegativedirectionRecosignalD4 == 16)
10347  HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-1 ; depth = 4 \b");
10348  HBnegativedirectionRecosignalD4->Draw("Error");
10349  kcountHBnegativedirectionRecosignalD4++;
10350  if (kcountHBnegativedirectionRecosignalD4 > 16)
10351  break; // 4x6 = 24
10352  } //ccctest>0
10353 
10354  } // for i
10355  } //if(jeta-41 < 0)
10356  } //for jeta
10358  c3x5->Update();
10359  c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth4HB.png");
10360  c3x5->Clear();
10361  // clean-up
10362  if (h2CeffHBnegativedirectionRecosignalD4)
10363  delete h2CeffHBnegativedirectionRecosignalD4;
10364 
10365  //===================================================================== END of Recosignal HB for phi-symmetry
10366  //===================================================================== END of Recosignal HB for phi-symmetry
10367  //===================================================================== END of Recosignal HB for phi-symmetry
10368 
10372  // int k_max[5]={0,4,7,4,4}; // maximum depth for each subdet
10373  //ndepth = k_max[3];
10374  ndepth = 7;
10375  // const int ndepth = 7;
10376  double arecosignalhe[ndepth][njeta][njphi];
10377  double recosignalvariancehe[ndepth][njeta][njphi];
10378  // RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR: Recosignal HE
10379  TH2F *recSignalEnergy1HE1 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy1_HE1");
10380  TH2F *recSignalEnergy0HE1 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HE1");
10381  TH2F *recSignalEnergyHE1 = (TH2F *)recSignalEnergy1HE1->Clone("recSignalEnergyHE1");
10382  recSignalEnergyHE1->Divide(recSignalEnergy1HE1, recSignalEnergy0HE1, 1, 1, "B");
10383  TH2F *recSignalEnergy1HE2 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy1_HE2");
10384  TH2F *recSignalEnergy0HE2 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HE2");
10385  TH2F *recSignalEnergyHE2 = (TH2F *)recSignalEnergy1HE2->Clone("recSignalEnergyHE2");
10386  recSignalEnergyHE2->Divide(recSignalEnergy1HE2, recSignalEnergy0HE2, 1, 1, "B");
10387  TH2F *recSignalEnergy1HE3 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy1_HE3");
10388  TH2F *recSignalEnergy0HE3 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HE3");
10389  TH2F *recSignalEnergyHE3 = (TH2F *)recSignalEnergy1HE3->Clone("recSignalEnergyHE3");
10390  recSignalEnergyHE3->Divide(recSignalEnergy1HE3, recSignalEnergy0HE3, 1, 1, "B");
10391  TH2F *recSignalEnergy1HE4 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy1_HE4");
10392  TH2F *recSignalEnergy0HE4 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HE4");
10393  TH2F *recSignalEnergyHE4 = (TH2F *)recSignalEnergy1HE4->Clone("recSignalEnergyHE4");
10394  recSignalEnergyHE4->Divide(recSignalEnergy1HE4, recSignalEnergy0HE4, 1, 1, "B");
10395  TH2F *recSignalEnergy1HE5 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy1_HE5");
10396  TH2F *recSignalEnergy0HE5 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HE5");
10397  TH2F *recSignalEnergyHE5 = (TH2F *)recSignalEnergy1HE5->Clone("recSignalEnergyHE5");
10398  recSignalEnergyHE5->Divide(recSignalEnergy1HE5, recSignalEnergy0HE5, 1, 1, "B");
10399  TH2F *recSignalEnergy1HE6 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy1_HE6");
10400  TH2F *recSignalEnergy0HE6 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HE6");
10401  TH2F *recSignalEnergyHE6 = (TH2F *)recSignalEnergy1HE6->Clone("recSignalEnergyHE6");
10402  recSignalEnergyHE6->Divide(recSignalEnergy1HE6, recSignalEnergy0HE6, 1, 1, "B");
10403  TH2F *recSignalEnergy1HE7 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy1_HE7");
10404  TH2F *recSignalEnergy0HE7 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HE7");
10405  TH2F *recSignalEnergyHE7 = (TH2F *)recSignalEnergy1HE7->Clone("recSignalEnergyHE7");
10406  recSignalEnergyHE7->Divide(recSignalEnergy1HE7, recSignalEnergy0HE7, 1, 1, "B");
10407  for (int jeta = 0; jeta < njeta; jeta++) {
10408  //====================================================================== PHI normalization & put R into massive arecosignalhe
10409  //preparation for PHI normalization:
10410  double sumrecosignalHE0 = 0;
10411  int nsumrecosignalHE0 = 0;
10412  double sumrecosignalHE1 = 0;
10413  int nsumrecosignalHE1 = 0;
10414  double sumrecosignalHE2 = 0;
10415  int nsumrecosignalHE2 = 0;
10416  double sumrecosignalHE3 = 0;
10417  int nsumrecosignalHE3 = 0;
10418  double sumrecosignalHE4 = 0;
10419  int nsumrecosignalHE4 = 0;
10420  double sumrecosignalHE5 = 0;
10421  int nsumrecosignalHE5 = 0;
10422  double sumrecosignalHE6 = 0;
10423  int nsumrecosignalHE6 = 0;
10424  for (int jphi = 0; jphi < njphi; jphi++) {
10425  arecosignalhe[0][jeta][jphi] = recSignalEnergyHE1->GetBinContent(jeta + 1, jphi + 1);
10426  arecosignalhe[1][jeta][jphi] = recSignalEnergyHE2->GetBinContent(jeta + 1, jphi + 1);
10427  arecosignalhe[2][jeta][jphi] = recSignalEnergyHE3->GetBinContent(jeta + 1, jphi + 1);
10428  arecosignalhe[3][jeta][jphi] = recSignalEnergyHE4->GetBinContent(jeta + 1, jphi + 1);
10429  arecosignalhe[4][jeta][jphi] = recSignalEnergyHE5->GetBinContent(jeta + 1, jphi + 1);
10430  arecosignalhe[5][jeta][jphi] = recSignalEnergyHE6->GetBinContent(jeta + 1, jphi + 1);
10431  arecosignalhe[6][jeta][jphi] = recSignalEnergyHE7->GetBinContent(jeta + 1, jphi + 1);
10432  if (arecosignalhe[0][jeta][jphi] > 0.) {
10433  sumrecosignalHE0 += arecosignalhe[0][jeta][jphi];
10434  ++nsumrecosignalHE0;
10435  }
10436  if (arecosignalhe[1][jeta][jphi] > 0.) {
10437  sumrecosignalHE1 += arecosignalhe[1][jeta][jphi];
10438  ++nsumrecosignalHE1;
10439  }
10440  if (arecosignalhe[2][jeta][jphi] > 0.) {
10441  sumrecosignalHE2 += arecosignalhe[2][jeta][jphi];
10442  ++nsumrecosignalHE2;
10443  }
10444  if (arecosignalhe[3][jeta][jphi] > 0.) {
10445  sumrecosignalHE3 += arecosignalhe[3][jeta][jphi];
10446  ++nsumrecosignalHE3;
10447  }
10448  if (arecosignalhe[4][jeta][jphi] > 0.) {
10449  sumrecosignalHE4 += arecosignalhe[4][jeta][jphi];
10450  ++nsumrecosignalHE4;
10451  }
10452  if (arecosignalhe[5][jeta][jphi] > 0.) {
10453  sumrecosignalHE5 += arecosignalhe[5][jeta][jphi];
10454  ++nsumrecosignalHE5;
10455  }
10456  if (arecosignalhe[6][jeta][jphi] > 0.) {
10457  sumrecosignalHE6 += arecosignalhe[6][jeta][jphi];
10458  ++nsumrecosignalHE6;
10459  }
10460  } // phi
10461  // PHI normalization:
10462  for (int jphi = 0; jphi < njphi; jphi++) {
10463  if (arecosignalhe[0][jeta][jphi] > 0.)
10464  arecosignalhe[0][jeta][jphi] /= (sumrecosignalHE0 / nsumrecosignalHE0);
10465  if (arecosignalhe[1][jeta][jphi] > 0.)
10466  arecosignalhe[1][jeta][jphi] /= (sumrecosignalHE1 / nsumrecosignalHE1);
10467  if (arecosignalhe[2][jeta][jphi] > 0.)
10468  arecosignalhe[2][jeta][jphi] /= (sumrecosignalHE2 / nsumrecosignalHE2);
10469  if (arecosignalhe[3][jeta][jphi] > 0.)
10470  arecosignalhe[3][jeta][jphi] /= (sumrecosignalHE3 / nsumrecosignalHE3);
10471  if (arecosignalhe[4][jeta][jphi] > 0.)
10472  arecosignalhe[4][jeta][jphi] /= (sumrecosignalHE4 / nsumrecosignalHE4);
10473  if (arecosignalhe[5][jeta][jphi] > 0.)
10474  arecosignalhe[5][jeta][jphi] /= (sumrecosignalHE5 / nsumrecosignalHE5);
10475  if (arecosignalhe[6][jeta][jphi] > 0.)
10476  arecosignalhe[6][jeta][jphi] /= (sumrecosignalHE6 / nsumrecosignalHE6);
10477  } // phi
10478  } //eta
10479  //------------------------ 2D-eta/phi-plot: R, averaged over depthes
10480  //======================================================================
10481  //======================================================================
10482  //cout<<" R2D-eta/phi-plot: R, averaged over depthes *****" <<endl;
10483  c2x1->Clear();
10485  c2x1->Divide(2, 1);
10486  c2x1->cd(1);
10487  TH2F *GefzRrecosignalHE42D = new TH2F("GefzRrecosignalHE42D", "", neta, -41., 41., nphi, 0., 72.);
10488  TH2F *GefzRrecosignalHE42D0 = new TH2F("GefzRrecosignalHE42D0", "", neta, -41., 41., nphi, 0., 72.);
10489  TH2F *GefzRrecosignalHE42DF = (TH2F *)GefzRrecosignalHE42D0->Clone("GefzRrecosignalHE42DF");
10490  for (int i = 0; i < ndepth; i++) {
10491  for (int jeta = 0; jeta < neta; jeta++) {
10492  for (int jphi = 0; jphi < nphi; jphi++) {
10493  double ccc1 = arecosignalhe[i][jeta][jphi];
10494  int k2plot = jeta - 41;
10495  int kkk = k2plot; //if(k2plot >0 ) kkk=k2plot+1; //-41 +41 !=0
10496  if (ccc1 != 0.) {
10497  GefzRrecosignalHE42D->Fill(kkk, jphi, ccc1);
10498  GefzRrecosignalHE42D0->Fill(kkk, jphi, 1.);
10499  }
10500  }
10501  }
10502  }
10503  GefzRrecosignalHE42DF->Divide(GefzRrecosignalHE42D, GefzRrecosignalHE42D0, 1, 1, "B"); // average A
10504  gPad->SetGridy();
10505  gPad->SetGridx(); // gPad->SetLogz();
10506  GefzRrecosignalHE42DF->SetXTitle("<R>_depth #eta \b");
10507  GefzRrecosignalHE42DF->SetYTitle(" #phi \b");
10508  GefzRrecosignalHE42DF->Draw("COLZ");
10509 
10510  c2x1->cd(2);
10511  TH1F *energyhitSignal_HE = (TH1F *)dir->FindObjectAny("h_energyhitSignal_HE");
10512  energyhitSignal_HE->SetMarkerStyle(20);
10513  energyhitSignal_HE->SetMarkerSize(0.4);
10514  energyhitSignal_HE->GetYaxis()->SetLabelSize(0.04);
10515  energyhitSignal_HE->SetXTitle("energyhitSignal_HE \b");
10516  energyhitSignal_HE->SetMarkerColor(2);
10517  energyhitSignal_HE->SetLineColor(0);
10518  gPad->SetGridy();
10519  gPad->SetGridx();
10520  energyhitSignal_HE->Draw("Error");
10521 
10523  c2x1->Update();
10524  c2x1->Print("RrecosignalGeneralD2PhiSymmetryHE.png");
10525  c2x1->Clear();
10526  // clean-up
10527  if (GefzRrecosignalHE42D)
10528  delete GefzRrecosignalHE42D;
10529  if (GefzRrecosignalHE42D0)
10530  delete GefzRrecosignalHE42D0;
10531  if (GefzRrecosignalHE42DF)
10532  delete GefzRrecosignalHE42DF;
10533  //====================================================================== 1D plot: R vs phi , averaged over depthes & eta
10534  //======================================================================
10535  //cout<<" 1D plot: R vs phi , averaged over depthes & eta *****" <<endl;
10536  c1x1->Clear();
10538  c1x1->Divide(1, 1);
10539  c1x1->cd(1);
10540  TH1F *GefzRrecosignalHE41D = new TH1F("GefzRrecosignalHE41D", "", nphi, 0., 72.);
10541  TH1F *GefzRrecosignalHE41D0 = new TH1F("GefzRrecosignalHE41D0", "", nphi, 0., 72.);
10542  TH1F *GefzRrecosignalHE41DF = (TH1F *)GefzRrecosignalHE41D0->Clone("GefzRrecosignalHE41DF");
10543  for (int jphi = 0; jphi < nphi; jphi++) {
10544  for (int jeta = 0; jeta < neta; jeta++) {
10545  for (int i = 0; i < ndepth; i++) {
10546  double ccc1 = arecosignalhe[i][jeta][jphi];
10547  if (ccc1 != 0.) {
10548  GefzRrecosignalHE41D->Fill(jphi, ccc1);
10549  GefzRrecosignalHE41D0->Fill(jphi, 1.);
10550  }
10551  }
10552  }
10553  }
10554  GefzRrecosignalHE41DF->Divide(
10555  GefzRrecosignalHE41D, GefzRrecosignalHE41D0, 1, 1, "B"); // R averaged over depthes & eta
10556  GefzRrecosignalHE41D0->Sumw2();
10557  // for (int jphi=1;jphi<73;jphi++) {GefzRrecosignalHE41DF->SetBinError(jphi,0.01);}
10558  gPad->SetGridy();
10559  gPad->SetGridx(); // gPad->SetLogz();
10560  GefzRrecosignalHE41DF->SetMarkerStyle(20);
10561  GefzRrecosignalHE41DF->SetMarkerSize(1.4);
10562  GefzRrecosignalHE41DF->GetZaxis()->SetLabelSize(0.08);
10563  GefzRrecosignalHE41DF->SetXTitle("#phi \b");
10564  GefzRrecosignalHE41DF->SetYTitle(" <R> \b");
10565  GefzRrecosignalHE41DF->SetZTitle("<R>_PHI - AllDepthes \b");
10566  GefzRrecosignalHE41DF->SetMarkerColor(4);
10567  GefzRrecosignalHE41DF->SetLineColor(
10568  4); // GefzRrecosignalHE41DF->SetMinimum(0.8); // GefzRrecosignalHE41DF->SetMaximum(1.000);
10569  GefzRrecosignalHE41DF->Draw("Error");
10571  c1x1->Update();
10572  c1x1->Print("RrecosignalGeneralD1PhiSymmetryHE.png");
10573  c1x1->Clear();
10574  // clean-up
10575  if (GefzRrecosignalHE41D)
10576  delete GefzRrecosignalHE41D;
10577  if (GefzRrecosignalHE41D0)
10578  delete GefzRrecosignalHE41D0;
10579  if (GefzRrecosignalHE41DF)
10580  delete GefzRrecosignalHE41DF;
10581 
10582  //========================================================================================== 4
10583  //======================================================================
10584  //======================================================================1D plot: R vs phi , different eta, depth=1
10585  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
10586  c3x5->Clear();
10588  c3x5->Divide(3, 5);
10589  c3x5->cd(1);
10590  int kcountHEpositivedirectionRecosignal1 = 1;
10591  TH1F *h2CeffHEpositivedirectionRecosignal1 = new TH1F("h2CeffHEpositivedirectionRecosignal1", "", nphi, 0., 72.);
10592  for (int jeta = 0; jeta < njeta; jeta++) {
10593  // positivedirectionRecosignal:
10594  if (jeta - 41 >= 0) {
10595  // for (int i=0;i<ndepth;i++) {
10596  // depth=1
10597  for (int i = 0; i < 1; i++) {
10598  TH1F *HEpositivedirectionRecosignal1 = (TH1F *)h2CeffHEpositivedirectionRecosignal1->Clone("twod1");
10599  float ccctest = 0; // to avoid empty massive elements
10600  for (int jphi = 0; jphi < nphi; jphi++) {
10601  double ccc1 = arecosignalhe[i][jeta][jphi];
10602  if (ccc1 != 0.) {
10603  HEpositivedirectionRecosignal1->Fill(jphi, ccc1);
10604  ccctest = 1.; //HEpositivedirectionRecosignal1->SetBinError(i,0.01);
10605  }
10606  } // for jphi
10607  if (ccctest > 0.) {
10608  // cout<<"444 kcountHEpositivedirectionRecosignal1 = "<<kcountHEpositivedirectionRecosignal1 <<" jeta-41= "<< jeta-41 <<endl;
10609  c3x5->cd(kcountHEpositivedirectionRecosignal1);
10610  HEpositivedirectionRecosignal1->SetMarkerStyle(20);
10611  HEpositivedirectionRecosignal1->SetMarkerSize(0.4);
10612  HEpositivedirectionRecosignal1->GetYaxis()->SetLabelSize(0.04);
10613  HEpositivedirectionRecosignal1->SetXTitle("HEpositivedirectionRecosignal1 \b");
10614  HEpositivedirectionRecosignal1->SetMarkerColor(2);
10615  HEpositivedirectionRecosignal1->SetLineColor(0);
10616  gPad->SetGridy();
10617  gPad->SetGridx();
10618  // gPad->SetLogy();
10619  if (kcountHEpositivedirectionRecosignal1 == 1)
10620  HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 17; depth = 1 \b");
10621  if (kcountHEpositivedirectionRecosignal1 == 2)
10622  HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 18; depth = 1 \b");
10623  if (kcountHEpositivedirectionRecosignal1 == 3)
10624  HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 19; depth = 1 \b");
10625  if (kcountHEpositivedirectionRecosignal1 == 4)
10626  HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 20; depth = 1 \b");
10627  if (kcountHEpositivedirectionRecosignal1 == 5)
10628  HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 21; depth = 1 \b");
10629  if (kcountHEpositivedirectionRecosignal1 == 6)
10630  HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 22; depth = 1 \b");
10631  if (kcountHEpositivedirectionRecosignal1 == 7)
10632  HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 23; depth = 1 \b");
10633  if (kcountHEpositivedirectionRecosignal1 == 8)
10634  HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 24; depth = 1 \b");
10635  if (kcountHEpositivedirectionRecosignal1 == 9)
10636  HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 25; depth = 1 \b");
10637  if (kcountHEpositivedirectionRecosignal1 == 10)
10638  HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 26; depth = 1 \b");
10639  if (kcountHEpositivedirectionRecosignal1 == 11)
10640  HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 27; depth = 1 \b");
10641  if (kcountHEpositivedirectionRecosignal1 == 12)
10642  HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 28; depth = 1 \b");
10643  HEpositivedirectionRecosignal1->Draw("Error");
10644  kcountHEpositivedirectionRecosignal1++;
10645  if (kcountHEpositivedirectionRecosignal1 > 12)
10646  break; // 4x6 = 24
10647  } //ccctest>0
10648 
10649  } // for i
10650  } //if(jeta-41 >= 0)
10651  } //for jeta
10653  c3x5->Update();
10654  c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth1HE.png");
10655  c3x5->Clear();
10656  // clean-up
10657  if (h2CeffHEpositivedirectionRecosignal1)
10658  delete h2CeffHEpositivedirectionRecosignal1;
10659 
10660  //========================================================================================== 5
10661  //======================================================================
10662  //======================================================================1D plot: R vs phi , different eta, depth=2
10663  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
10664  c3x5->Clear();
10666  c3x5->Divide(3, 5);
10667  c3x5->cd(1);
10668  int kcountHEpositivedirectionRecosignal2 = 1;
10669  TH1F *h2CeffHEpositivedirectionRecosignal2 = new TH1F("h2CeffHEpositivedirectionRecosignal2", "", nphi, 0., 72.);
10670  for (int jeta = 0; jeta < njeta; jeta++) {
10671  // positivedirectionRecosignal:
10672  if (jeta - 41 >= 0) {
10673  // for (int i=0;i<ndepth;i++) {
10674  // depth=2
10675  for (int i = 1; i < 2; i++) {
10676  TH1F *HEpositivedirectionRecosignal2 = (TH1F *)h2CeffHEpositivedirectionRecosignal2->Clone("twod1");
10677  float ccctest = 0; // to avoid empty massive elements
10678  for (int jphi = 0; jphi < nphi; jphi++) {
10679  double ccc1 = arecosignalhe[i][jeta][jphi];
10680  if (ccc1 != 0.) {
10681  HEpositivedirectionRecosignal2->Fill(jphi, ccc1);
10682  ccctest = 1.; //HEpositivedirectionRecosignal2->SetBinError(i,0.01);
10683  }
10684  } // for jphi
10685  if (ccctest > 0.) {
10686  //cout<<"555 kcountHEpositivedirectionRecosignal2 = "<<kcountHEpositivedirectionRecosignal2 <<" jeta-41= "<< jeta-41 <<endl;
10687  c3x5->cd(kcountHEpositivedirectionRecosignal2);
10688  HEpositivedirectionRecosignal2->SetMarkerStyle(20);
10689  HEpositivedirectionRecosignal2->SetMarkerSize(0.4);
10690  HEpositivedirectionRecosignal2->GetYaxis()->SetLabelSize(0.04);
10691  HEpositivedirectionRecosignal2->SetXTitle("HEpositivedirectionRecosignal2 \b");
10692  HEpositivedirectionRecosignal2->SetMarkerColor(2);
10693  HEpositivedirectionRecosignal2->SetLineColor(0);
10694  gPad->SetGridy();
10695  gPad->SetGridx();
10696  // gPad->SetLogy();
10697  if (kcountHEpositivedirectionRecosignal2 == 1)
10698  HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 16; depth = 2 \b");
10699  if (kcountHEpositivedirectionRecosignal2 == 2)
10700  HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 17; depth = 2 \b");
10701  if (kcountHEpositivedirectionRecosignal2 == 3)
10702  HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 18; depth = 2 \b");
10703  if (kcountHEpositivedirectionRecosignal2 == 4)
10704  HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 19; depth = 2 \b");
10705  if (kcountHEpositivedirectionRecosignal2 == 5)
10706  HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 20; depth = 2 \b");
10707  if (kcountHEpositivedirectionRecosignal2 == 6)
10708  HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 21; depth = 2 \b");
10709  if (kcountHEpositivedirectionRecosignal2 == 7)
10710  HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 22; depth = 2 \b");
10711  if (kcountHEpositivedirectionRecosignal2 == 8)
10712  HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 23; depth = 2 \b");
10713  if (kcountHEpositivedirectionRecosignal2 == 9)
10714  HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 24; depth = 2 \b");
10715  if (kcountHEpositivedirectionRecosignal2 == 10)
10716  HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 25; depth = 2 \b");
10717  if (kcountHEpositivedirectionRecosignal2 == 11)
10718  HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 26; depth = 2 \b");
10719  if (kcountHEpositivedirectionRecosignal2 == 12)
10720  HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 27; depth = 2 \b");
10721  if (kcountHEpositivedirectionRecosignal2 == 13)
10722  HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 28; depth = 2 \b");
10723  HEpositivedirectionRecosignal2->Draw("Error");
10724  kcountHEpositivedirectionRecosignal2++;
10725  if (kcountHEpositivedirectionRecosignal2 > 13)
10726  break; // 4x6 = 24
10727  } //ccctest>0
10728 
10729  } // for i
10730  } //if(jeta-41 >= 0)
10731  } //for jeta
10733  c3x5->Update();
10734  c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth2HE.png");
10735  c3x5->Clear();
10736  // clean-up
10737  if (h2CeffHEpositivedirectionRecosignal2)
10738  delete h2CeffHEpositivedirectionRecosignal2;
10739  //========================================================================================== 6
10740  //======================================================================
10741  //======================================================================1D plot: R vs phi , different eta, depth=3
10742  //cout<<" 1D plot: R vs phi , different eta, depth=3 *****" <<endl;
10743  c3x5->Clear();
10745  c3x5->Divide(3, 5);
10746  c3x5->cd(1);
10747  int kcountHEpositivedirectionRecosignal3 = 1;
10748  TH1F *h2CeffHEpositivedirectionRecosignal3 = new TH1F("h2CeffHEpositivedirectionRecosignal3", "", nphi, 0., 72.);
10749  for (int jeta = 0; jeta < njeta; jeta++) {
10750  // positivedirectionRecosignal:
10751  if (jeta - 41 >= 0) {
10752  // for (int i=0;i<ndepth;i++) {
10753  // depth=3
10754  for (int i = 2; i < 3; i++) {
10755  TH1F *HEpositivedirectionRecosignal3 = (TH1F *)h2CeffHEpositivedirectionRecosignal3->Clone("twod1");
10756  float ccctest = 0; // to avoid empty massive elements
10757  for (int jphi = 0; jphi < nphi; jphi++) {
10758  double ccc1 = arecosignalhe[i][jeta][jphi];
10759  if (ccc1 != 0.) {
10760  HEpositivedirectionRecosignal3->Fill(jphi, ccc1);
10761  ccctest = 1.; //HEpositivedirectionRecosignal3->SetBinError(i,0.01);
10762  }
10763  } // for jphi
10764  if (ccctest > 0.) {
10765  //cout<<"666 kcountHEpositivedirectionRecosignal3 = "<<kcountHEpositivedirectionRecosignal3 <<" jeta-41= "<< jeta-41 <<endl;
10766  c3x5->cd(kcountHEpositivedirectionRecosignal3);
10767  HEpositivedirectionRecosignal3->SetMarkerStyle(20);
10768  HEpositivedirectionRecosignal3->SetMarkerSize(0.4);
10769  HEpositivedirectionRecosignal3->GetYaxis()->SetLabelSize(0.04);
10770  HEpositivedirectionRecosignal3->SetXTitle("HEpositivedirectionRecosignal3 \b");
10771  HEpositivedirectionRecosignal3->SetMarkerColor(2);
10772  HEpositivedirectionRecosignal3->SetLineColor(0);
10773  gPad->SetGridy();
10774  gPad->SetGridx();
10775  // gPad->SetLogy();
10776  if (kcountHEpositivedirectionRecosignal3 == 1)
10777  HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 16; depth = 3 \b");
10778  if (kcountHEpositivedirectionRecosignal3 == 2)
10779  HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 17; depth = 3 \b");
10780  if (kcountHEpositivedirectionRecosignal3 == 3)
10781  HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 18; depth = 3 \b");
10782  if (kcountHEpositivedirectionRecosignal3 == 4)
10783  HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 19; depth = 3 \b");
10784  if (kcountHEpositivedirectionRecosignal3 == 5)
10785  HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 20; depth = 3 \b");
10786  if (kcountHEpositivedirectionRecosignal3 == 6)
10787  HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 21; depth = 3 \b");
10788  if (kcountHEpositivedirectionRecosignal3 == 7)
10789  HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 22; depth = 3 \b");
10790  if (kcountHEpositivedirectionRecosignal3 == 8)
10791  HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 23; depth = 3 \b");
10792  if (kcountHEpositivedirectionRecosignal3 == 9)
10793  HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 24; depth = 3 \b");
10794  if (kcountHEpositivedirectionRecosignal3 == 10)
10795  HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 25; depth = 3 \b");
10796  if (kcountHEpositivedirectionRecosignal3 == 11)
10797  HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 26; depth = 3 \b");
10798  if (kcountHEpositivedirectionRecosignal3 == 12)
10799  HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 27; depth = 3 \b");
10800  if (kcountHEpositivedirectionRecosignal3 == 13)
10801  HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 28; depth = 3 \b");
10802  HEpositivedirectionRecosignal3->Draw("Error");
10803  kcountHEpositivedirectionRecosignal3++;
10804  if (kcountHEpositivedirectionRecosignal3 > 13)
10805  break; // 4x6 = 24
10806  } //ccctest>0
10807 
10808  } // for i
10809  } //if(jeta-41 >= 0)
10810  } //for jeta
10812  c3x5->Update();
10813  c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth3HE.png");
10814  c3x5->Clear();
10815  // clean-up
10816  if (h2CeffHEpositivedirectionRecosignal3)
10817  delete h2CeffHEpositivedirectionRecosignal3;
10818  //========================================================================================== 7
10819  //======================================================================
10820  //======================================================================1D plot: R vs phi , different eta, depth=4
10821  //cout<<" 1D plot: R vs phi , different eta, depth=4 *****" <<endl;
10822  c3x5->Clear();
10824  c3x5->Divide(3, 5);
10825  c3x5->cd(1);
10826  int kcountHEpositivedirectionRecosignal4 = 1;
10827  TH1F *h2CeffHEpositivedirectionRecosignal4 = new TH1F("h2CeffHEpositivedirectionRecosignal4", "", nphi, 0., 72.);
10828 
10829  for (int jeta = 0; jeta < njeta; jeta++) {
10830  // positivedirectionRecosignal:
10831  if (jeta - 41 >= 0) {
10832  // for (int i=0;i<ndepth;i++) {
10833  // depth=4
10834  for (int i = 3; i < 4; i++) {
10835  TH1F *HEpositivedirectionRecosignal4 = (TH1F *)h2CeffHEpositivedirectionRecosignal4->Clone("twod1");
10836 
10837  float ccctest = 0; // to avoid empty massive elements
10838  for (int jphi = 0; jphi < nphi; jphi++) {
10839  double ccc1 = arecosignalhe[i][jeta][jphi];
10840  if (ccc1 != 0.) {
10841  HEpositivedirectionRecosignal4->Fill(jphi, ccc1);
10842  ccctest = 1.; //HEpositivedirectionRecosignal4->SetBinError(i,0.01);
10843  }
10844  } // for jphi
10845  if (ccctest > 0.) {
10846  //cout<<"777 kcountHEpositivedirectionRecosignal4 = "<<kcountHEpositivedirectionRecosignal4 <<" jeta-41= "<< jeta-41 <<endl;
10847  c3x5->cd(kcountHEpositivedirectionRecosignal4);
10848  HEpositivedirectionRecosignal4->SetMarkerStyle(20);
10849  HEpositivedirectionRecosignal4->SetMarkerSize(0.4);
10850  HEpositivedirectionRecosignal4->GetYaxis()->SetLabelSize(0.04);
10851  HEpositivedirectionRecosignal4->SetXTitle("HEpositivedirectionRecosignal4 \b");
10852  HEpositivedirectionRecosignal4->SetMarkerColor(2);
10853  HEpositivedirectionRecosignal4->SetLineColor(0);
10854  gPad->SetGridy();
10855  gPad->SetGridx();
10856  // gPad->SetLogy();
10857  if (kcountHEpositivedirectionRecosignal4 == 1)
10858  HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 15; depth = 4 \b");
10859  if (kcountHEpositivedirectionRecosignal4 == 2)
10860  HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 17; depth = 4 \b");
10861  if (kcountHEpositivedirectionRecosignal4 == 3)
10862  HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 18; depth = 4 \b");
10863  if (kcountHEpositivedirectionRecosignal4 == 4)
10864  HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 19; depth = 4 \b");
10865  if (kcountHEpositivedirectionRecosignal4 == 5)
10866  HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 20; depth = 4 \b");
10867  if (kcountHEpositivedirectionRecosignal4 == 6)
10868  HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 21; depth = 4 \b");
10869  if (kcountHEpositivedirectionRecosignal4 == 7)
10870  HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 22; depth = 4 \b");
10871  if (kcountHEpositivedirectionRecosignal4 == 8)
10872  HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 23; depth = 4 \b");
10873  if (kcountHEpositivedirectionRecosignal4 == 9)
10874  HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 24; depth = 4 \b");
10875  if (kcountHEpositivedirectionRecosignal4 == 10)
10876  HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 25; depth = 4 \b");
10877  if (kcountHEpositivedirectionRecosignal4 == 11)
10878  HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 26; depth = 4 \b");
10879  if (kcountHEpositivedirectionRecosignal4 == 12)
10880  HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 27; depth = 4 \b");
10881  HEpositivedirectionRecosignal4->Draw("Error");
10882  kcountHEpositivedirectionRecosignal4++;
10883  if (kcountHEpositivedirectionRecosignal4 > 12)
10884  break; // 4x6 = 24
10885  } //ccctest>0
10886 
10887  } // for i
10888  } //if(jeta-41 >= 0)
10889  } //for jeta
10891  c3x5->Update();
10892  c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth4HE.png");
10893  c3x5->Clear();
10894  // clean-up
10895  if (h2CeffHEpositivedirectionRecosignal4)
10896  delete h2CeffHEpositivedirectionRecosignal4;
10897  //========================================================================================== 8
10898  //======================================================================
10899  //======================================================================1D plot: R vs phi , different eta, depth=5
10900  //cout<<" 1D plot: R vs phi , different eta, depth=5 *****" <<endl;
10901  c3x5->Clear();
10903  c3x5->Divide(3, 5);
10904  c3x5->cd(1);
10905  int kcountHEpositivedirectionRecosignal5 = 1;
10906  TH1F *h2CeffHEpositivedirectionRecosignal5 = new TH1F("h2CeffHEpositivedirectionRecosignal5", "", nphi, 0., 72.);
10907 
10908  for (int jeta = 0; jeta < njeta; jeta++) {
10909  // positivedirectionRecosignal:
10910  if (jeta - 41 >= 0) {
10911  // for (int i=0;i<ndepth;i++) {
10912  // depth=5
10913  for (int i = 4; i < 5; i++) {
10914  TH1F *HEpositivedirectionRecosignal5 = (TH1F *)h2CeffHEpositivedirectionRecosignal5->Clone("twod1");
10915 
10916  float ccctest = 0; // to avoid empty massive elements
10917  for (int jphi = 0; jphi < nphi; jphi++) {
10918  // cout<<"888 initial kcountHEpositivedirectionRecosignal5 = "<<kcountHEpositivedirectionRecosignal5 <<" jeta-41= "<< jeta-41 <<" jphi= "<< jphi <<" arecosignalhe[i][jeta][jphi]= "<< arecosignalhe[i][jeta][jphi] <<" depth= "<< i <<endl;
10919 
10920  double ccc1 = arecosignalhe[i][jeta][jphi];
10921  if (ccc1 != 0.) {
10922  HEpositivedirectionRecosignal5->Fill(jphi, ccc1);
10923  ccctest = 1.; //HEpositivedirectionRecosignal5->SetBinError(i,0.01);
10924  }
10925  } // for jphi
10926  if (ccctest > 0.) {
10927  //cout<<"888 kcountHEpositivedirectionRecosignal5 = "<<kcountHEpositivedirectionRecosignal5 <<" jeta-41= "<< jeta-41 <<endl;
10928  c3x5->cd(kcountHEpositivedirectionRecosignal5);
10929  HEpositivedirectionRecosignal5->SetMarkerStyle(20);
10930  HEpositivedirectionRecosignal5->SetMarkerSize(0.4);
10931  HEpositivedirectionRecosignal5->GetYaxis()->SetLabelSize(0.04);
10932  HEpositivedirectionRecosignal5->SetXTitle("HEpositivedirectionRecosignal5 \b");
10933  HEpositivedirectionRecosignal5->SetMarkerColor(2);
10934  HEpositivedirectionRecosignal5->SetLineColor(0);
10935  gPad->SetGridy();
10936  gPad->SetGridx();
10937  // gPad->SetLogy();
10938  if (kcountHEpositivedirectionRecosignal5 == 1)
10939  HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 17; depth = 5 \b");
10940  if (kcountHEpositivedirectionRecosignal5 == 2)
10941  HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 18; depth = 5 \b");
10942  if (kcountHEpositivedirectionRecosignal5 == 3)
10943  HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 19; depth = 5 \b");
10944  if (kcountHEpositivedirectionRecosignal5 == 4)
10945  HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 20; depth = 5 \b");
10946  if (kcountHEpositivedirectionRecosignal5 == 5)
10947  HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 21; depth = 5 \b");
10948  if (kcountHEpositivedirectionRecosignal5 == 6)
10949  HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 22; depth = 5 \b");
10950  if (kcountHEpositivedirectionRecosignal5 == 7)
10951  HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 23; depth = 5 \b");
10952  if (kcountHEpositivedirectionRecosignal5 == 8)
10953  HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 24; depth = 5 \b");
10954  if (kcountHEpositivedirectionRecosignal5 == 9)
10955  HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 25; depth = 5 \b");
10956  if (kcountHEpositivedirectionRecosignal5 == 10)
10957  HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 26; depth = 5 \b");
10958  if (kcountHEpositivedirectionRecosignal5 == 11)
10959  HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 27; depth = 5 \b");
10960  HEpositivedirectionRecosignal5->Draw("Error");
10961  kcountHEpositivedirectionRecosignal5++;
10962  if (kcountHEpositivedirectionRecosignal5 > 11)
10963  break; // 4x6 = 24
10964  } //ccctest>0
10965 
10966  } // for i
10967  } //if(jeta-41 >= 0)
10968  } //for jeta
10970  c3x5->Update();
10971  c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth5HE.png");
10972  c3x5->Clear();
10973  // clean-up
10974  if (h2CeffHEpositivedirectionRecosignal5)
10975  delete h2CeffHEpositivedirectionRecosignal5;
10976  //========================================================================================== 9
10977  //======================================================================
10978  //======================================================================1D plot: R vs phi , different eta, depth=6
10979  //cout<<" 1D plot: R vs phi , different eta, depth=6 *****" <<endl;
10980  c3x5->Clear();
10982  c3x5->Divide(3, 5);
10983  c3x5->cd(1);
10984  int kcountHEpositivedirectionRecosignal6 = 1;
10985  TH1F *h2CeffHEpositivedirectionRecosignal6 = new TH1F("h2CeffHEpositivedirectionRecosignal6", "", nphi, 0., 72.);
10986 
10987  for (int jeta = 0; jeta < njeta; jeta++) {
10988  // positivedirectionRecosignal:
10989  if (jeta - 41 >= 0) {
10990  // for (int i=0;i<ndepth;i++) {
10991  // depth=6
10992  for (int i = 5; i < 6; i++) {
10993  TH1F *HEpositivedirectionRecosignal6 = (TH1F *)h2CeffHEpositivedirectionRecosignal6->Clone("twod1");
10994 
10995  float ccctest = 0; // to avoid empty massive elements
10996  for (int jphi = 0; jphi < nphi; jphi++) {
10997  double ccc1 = arecosignalhe[i][jeta][jphi];
10998  if (ccc1 != 0.) {
10999  HEpositivedirectionRecosignal6->Fill(jphi, ccc1);
11000  ccctest = 1.; //HEpositivedirectionRecosignal6->SetBinError(i,0.01);
11001  }
11002  } // for jphi
11003  if (ccctest > 0.) {
11004  //cout<<"999 kcountHEpositivedirectionRecosignal6 = "<<kcountHEpositivedirectionRecosignal6 <<" jeta-41= "<< jeta-41 <<endl;
11005  c3x5->cd(kcountHEpositivedirectionRecosignal6);
11006  HEpositivedirectionRecosignal6->SetMarkerStyle(20);
11007  HEpositivedirectionRecosignal6->SetMarkerSize(0.4);
11008  HEpositivedirectionRecosignal6->GetYaxis()->SetLabelSize(0.04);
11009  HEpositivedirectionRecosignal6->SetXTitle("HEpositivedirectionRecosignal6 \b");
11010  HEpositivedirectionRecosignal6->SetMarkerColor(2);
11011  HEpositivedirectionRecosignal6->SetLineColor(0);
11012  gPad->SetGridy();
11013  gPad->SetGridx();
11014  // gPad->SetLogy();
11015  if (kcountHEpositivedirectionRecosignal6 == 1)
11016  HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 18; depth = 6 \b");
11017  if (kcountHEpositivedirectionRecosignal6 == 2)
11018  HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 19; depth = 6 \b");
11019  if (kcountHEpositivedirectionRecosignal6 == 3)
11020  HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 20; depth = 6 \b");
11021  if (kcountHEpositivedirectionRecosignal6 == 4)
11022  HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 21; depth = 6 \b");
11023  if (kcountHEpositivedirectionRecosignal6 == 5)
11024  HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 22; depth = 6 \b");
11025  if (kcountHEpositivedirectionRecosignal6 == 6)
11026  HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 23; depth = 6 \b");
11027  if (kcountHEpositivedirectionRecosignal6 == 7)
11028  HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 24; depth = 6 \b");
11029  if (kcountHEpositivedirectionRecosignal6 == 8)
11030  HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 25; depth = 6 \b");
11031  if (kcountHEpositivedirectionRecosignal6 == 9)
11032  HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 26; depth = 6 \b");
11033  if (kcountHEpositivedirectionRecosignal6 == 10)
11034  HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 27; depth = 6 \b");
11035  HEpositivedirectionRecosignal6->Draw("Error");
11036  kcountHEpositivedirectionRecosignal6++;
11037  if (kcountHEpositivedirectionRecosignal6 > 10)
11038  break; // 4x6 = 24
11039  } //ccctest>0
11040 
11041  } // for i
11042  } //if(jeta-41 >= 0)
11043  } //for jeta
11045  c3x5->Update();
11046  c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth6HE.png");
11047  c3x5->Clear();
11048  // clean-up
11049  if (h2CeffHEpositivedirectionRecosignal6)
11050  delete h2CeffHEpositivedirectionRecosignal6;
11051  //========================================================================================== 10
11052  //======================================================================
11053  //======================================================================1D plot: R vs phi , different eta, depth=7
11054  //cout<<" 1D plot: R vs phi , different eta, depth=7 *****" <<endl;
11055  c3x5->Clear();
11057  c3x5->Divide(3, 5);
11058  c3x5->cd(1);
11059  int kcountHEpositivedirectionRecosignal7 = 1;
11060  TH1F *h2CeffHEpositivedirectionRecosignal7 = new TH1F("h2CeffHEpositivedirectionRecosignal7", "", nphi, 0., 72.);
11061 
11062  for (int jeta = 0; jeta < njeta; jeta++) {
11063  // positivedirectionRecosignal:
11064  if (jeta - 41 >= 0) {
11065  // for (int i=0;i<ndepth;i++) {
11066  // depth=7
11067  for (int i = 6; i < 7; i++) {
11068  TH1F *HEpositivedirectionRecosignal7 = (TH1F *)h2CeffHEpositivedirectionRecosignal7->Clone("twod1");
11069 
11070  float ccctest = 0; // to avoid empty massive elements
11071  for (int jphi = 0; jphi < nphi; jphi++) {
11072  double ccc1 = arecosignalhe[i][jeta][jphi];
11073  if (ccc1 != 0.) {
11074  HEpositivedirectionRecosignal7->Fill(jphi, ccc1);
11075  ccctest = 1.; //HEpositivedirectionRecosignal7->SetBinError(i,0.01);
11076  }
11077  } // for jphi
11078  if (ccctest > 0.) {
11079  //cout<<"1010 kcountHEpositivedirectionRecosignal7 = "<<kcountHEpositivedirectionRecosignal7 <<" jeta-41= "<< jeta-41 <<endl;
11080  c3x5->cd(kcountHEpositivedirectionRecosignal7);
11081  HEpositivedirectionRecosignal7->SetMarkerStyle(20);
11082  HEpositivedirectionRecosignal7->SetMarkerSize(0.4);
11083  HEpositivedirectionRecosignal7->GetYaxis()->SetLabelSize(0.04);
11084  HEpositivedirectionRecosignal7->SetXTitle("HEpositivedirectionRecosignal7 \b");
11085  HEpositivedirectionRecosignal7->SetMarkerColor(2);
11086  HEpositivedirectionRecosignal7->SetLineColor(0);
11087  gPad->SetGridy();
11088  gPad->SetGridx();
11089  // gPad->SetLogy();
11090  if (kcountHEpositivedirectionRecosignal7 == 1)
11091  HEpositivedirectionRecosignal7->SetXTitle("R for HE+ jeta = 25; depth = 7 \b");
11092  if (kcountHEpositivedirectionRecosignal7 == 2)
11093  HEpositivedirectionRecosignal7->SetXTitle("R for HE+ jeta = 26; depth = 7 \b");
11094  if (kcountHEpositivedirectionRecosignal7 == 3)
11095  HEpositivedirectionRecosignal7->SetXTitle("R for HE+ jeta = 27; depth = 7 \b");
11096  HEpositivedirectionRecosignal7->Draw("Error");
11097  kcountHEpositivedirectionRecosignal7++;
11098  if (kcountHEpositivedirectionRecosignal7 > 3)
11099  break; //
11100  } //ccctest>0
11101 
11102  } // for i
11103  } //if(jeta-41 >= 0)
11104  } //for jeta
11106  c3x5->Update();
11107  c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth7HE.png");
11108  c3x5->Clear();
11109  // clean-up
11110  if (h2CeffHEpositivedirectionRecosignal7)
11111  delete h2CeffHEpositivedirectionRecosignal7;
11112 
11114  //========================================================================================== 1114
11115  //======================================================================
11116  //======================================================================1D plot: R vs phi , different eta, depth=1
11117  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
11118  c3x5->Clear();
11120  c3x5->Divide(3, 5);
11121  c3x5->cd(1);
11122  int kcountHEnegativedirectionRecosignal1 = 1;
11123  TH1F *h2CeffHEnegativedirectionRecosignal1 = new TH1F("h2CeffHEnegativedirectionRecosignal1", "", nphi, 0., 72.);
11124  for (int jeta = 0; jeta < njeta; jeta++) {
11125  // negativedirectionRecosignal:
11126  if (jeta - 41 < 0) {
11127  // for (int i=0;i<ndepth;i++) {
11128  // depth=1
11129  for (int i = 0; i < 1; i++) {
11130  TH1F *HEnegativedirectionRecosignal1 = (TH1F *)h2CeffHEnegativedirectionRecosignal1->Clone("twod1");
11131  float ccctest = 0; // to avoid empty massive elements
11132  for (int jphi = 0; jphi < nphi; jphi++) {
11133  double ccc1 = arecosignalhe[i][jeta][jphi];
11134  if (ccc1 != 0.) {
11135  HEnegativedirectionRecosignal1->Fill(jphi, ccc1);
11136  ccctest = 1.; //HEnegativedirectionRecosignal1->SetBinError(i,0.01);
11137  }
11138  } // for jphi
11139  if (ccctest > 0.) {
11140  // cout<<"444 kcountHEnegativedirectionRecosignal1 = "<<kcountHEnegativedirectionRecosignal1 <<" jeta-41= "<< jeta-41 <<endl;
11141  c3x5->cd(kcountHEnegativedirectionRecosignal1);
11142  HEnegativedirectionRecosignal1->SetMarkerStyle(20);
11143  HEnegativedirectionRecosignal1->SetMarkerSize(0.4);
11144  HEnegativedirectionRecosignal1->GetYaxis()->SetLabelSize(0.04);
11145  HEnegativedirectionRecosignal1->SetXTitle("HEnegativedirectionRecosignal1 \b");
11146  HEnegativedirectionRecosignal1->SetMarkerColor(2);
11147  HEnegativedirectionRecosignal1->SetLineColor(0);
11148  gPad->SetGridy();
11149  gPad->SetGridx();
11150  // gPad->SetLogy();
11151  if (kcountHEnegativedirectionRecosignal1 == 1)
11152  HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-29; depth = 1 \b");
11153  if (kcountHEnegativedirectionRecosignal1 == 2)
11154  HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-28; depth = 1 \b");
11155  if (kcountHEnegativedirectionRecosignal1 == 3)
11156  HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-27; depth = 1 \b");
11157  if (kcountHEnegativedirectionRecosignal1 == 4)
11158  HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-26; depth = 1 \b");
11159  if (kcountHEnegativedirectionRecosignal1 == 5)
11160  HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-25; depth = 1 \b");
11161  if (kcountHEnegativedirectionRecosignal1 == 6)
11162  HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-24; depth = 1 \b");
11163  if (kcountHEnegativedirectionRecosignal1 == 7)
11164  HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-23; depth = 1 \b");
11165  if (kcountHEnegativedirectionRecosignal1 == 8)
11166  HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-22; depth = 1 \b");
11167  if (kcountHEnegativedirectionRecosignal1 == 9)
11168  HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-21; depth = 1 \b");
11169  if (kcountHEnegativedirectionRecosignal1 == 10)
11170  HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-20; depth = 1 \b");
11171  if (kcountHEnegativedirectionRecosignal1 == 11)
11172  HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-19; depth = 1 \b");
11173  if (kcountHEnegativedirectionRecosignal1 == 12)
11174  HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-18; depth = 1 \b");
11175  HEnegativedirectionRecosignal1->Draw("Error");
11176  kcountHEnegativedirectionRecosignal1++;
11177  if (kcountHEnegativedirectionRecosignal1 > 12)
11178  break; // 4x6 = 24
11179  } //ccctest>0
11180 
11181  } // for i
11182  } //if(jeta-41 < 0)
11183  } //for jeta
11185  c3x5->Update();
11186  c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth1HE.png");
11187  c3x5->Clear();
11188  // clean-up
11189  if (h2CeffHEnegativedirectionRecosignal1)
11190  delete h2CeffHEnegativedirectionRecosignal1;
11191 
11192  //========================================================================================== 1115
11193  //======================================================================
11194  //======================================================================1D plot: R vs phi , different eta, depth=2
11195  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
11196  c3x5->Clear();
11198  c3x5->Divide(3, 5);
11199  c3x5->cd(1);
11200  int kcountHEnegativedirectionRecosignal2 = 1;
11201  TH1F *h2CeffHEnegativedirectionRecosignal2 = new TH1F("h2CeffHEnegativedirectionRecosignal2", "", nphi, 0., 72.);
11202  for (int jeta = 0; jeta < njeta; jeta++) {
11203  // negativedirectionRecosignal:
11204  if (jeta - 41 < 0) {
11205  // for (int i=0;i<ndepth;i++) {
11206  // depth=2
11207  for (int i = 1; i < 2; i++) {
11208  TH1F *HEnegativedirectionRecosignal2 = (TH1F *)h2CeffHEnegativedirectionRecosignal2->Clone("twod1");
11209  float ccctest = 0; // to avoid empty massive elements
11210  for (int jphi = 0; jphi < nphi; jphi++) {
11211  double ccc1 = arecosignalhe[i][jeta][jphi];
11212  if (ccc1 != 0.) {
11213  HEnegativedirectionRecosignal2->Fill(jphi, ccc1);
11214  ccctest = 1.; //HEnegativedirectionRecosignal2->SetBinError(i,0.01);
11215  }
11216  } // for jphi
11217  if (ccctest > 0.) {
11218  //cout<<"555 kcountHEnegativedirectionRecosignal2 = "<<kcountHEnegativedirectionRecosignal2 <<" jeta-41= "<< jeta-41 <<endl;
11219  c3x5->cd(kcountHEnegativedirectionRecosignal2);
11220  HEnegativedirectionRecosignal2->SetMarkerStyle(20);
11221  HEnegativedirectionRecosignal2->SetMarkerSize(0.4);
11222  HEnegativedirectionRecosignal2->GetYaxis()->SetLabelSize(0.04);
11223  HEnegativedirectionRecosignal2->SetXTitle("HEnegativedirectionRecosignal2 \b");
11224  HEnegativedirectionRecosignal2->SetMarkerColor(2);
11225  HEnegativedirectionRecosignal2->SetLineColor(0);
11226  gPad->SetGridy();
11227  gPad->SetGridx();
11228  // gPad->SetLogy();
11229  if (kcountHEnegativedirectionRecosignal2 == 1)
11230  HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-29; depth = 2 \b");
11231  if (kcountHEnegativedirectionRecosignal2 == 2)
11232  HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-28; depth = 2 \b");
11233  if (kcountHEnegativedirectionRecosignal2 == 3)
11234  HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-27; depth = 2 \b");
11235  if (kcountHEnegativedirectionRecosignal2 == 4)
11236  HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-26; depth = 2 \b");
11237  if (kcountHEnegativedirectionRecosignal2 == 5)
11238  HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-25; depth = 2 \b");
11239  if (kcountHEnegativedirectionRecosignal2 == 6)
11240  HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-24; depth = 2 \b");
11241  if (kcountHEnegativedirectionRecosignal2 == 7)
11242  HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-23; depth = 2 \b");
11243  if (kcountHEnegativedirectionRecosignal2 == 8)
11244  HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-22; depth = 2 \b");
11245  if (kcountHEnegativedirectionRecosignal2 == 9)
11246  HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-21; depth = 2 \b");
11247  if (kcountHEnegativedirectionRecosignal2 == 10)
11248  HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-20; depth = 2 \b");
11249  if (kcountHEnegativedirectionRecosignal2 == 11)
11250  HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-19; depth = 2 \b");
11251  if (kcountHEnegativedirectionRecosignal2 == 12)
11252  HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-18; depth = 2 \b");
11253  if (kcountHEnegativedirectionRecosignal2 == 13)
11254  HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-17; depth = 2 \b");
11255  HEnegativedirectionRecosignal2->Draw("Error");
11256  kcountHEnegativedirectionRecosignal2++;
11257  if (kcountHEnegativedirectionRecosignal2 > 13)
11258  break; // 4x6 = 24
11259  } //ccctest>0
11260 
11261  } // for i
11262  } //if(jeta-41 < 0)
11263  } //for jeta
11265  c3x5->Update();
11266  c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth2HE.png");
11267  c3x5->Clear();
11268  // clean-up
11269  if (h2CeffHEnegativedirectionRecosignal2)
11270  delete h2CeffHEnegativedirectionRecosignal2;
11271  //========================================================================================== 1116
11272  //======================================================================
11273  //======================================================================1D plot: R vs phi , different eta, depth=3
11274  //cout<<" 1D plot: R vs phi , different eta, depth=3 *****" <<endl;
11275  c3x5->Clear();
11277  c3x5->Divide(3, 5);
11278  c3x5->cd(1);
11279  int kcountHEnegativedirectionRecosignal3 = 1;
11280  TH1F *h2CeffHEnegativedirectionRecosignal3 = new TH1F("h2CeffHEnegativedirectionRecosignal3", "", nphi, 0., 72.);
11281  for (int jeta = 0; jeta < njeta; jeta++) {
11282  // negativedirectionRecosignal:
11283  if (jeta - 41 < 0) {
11284  // for (int i=0;i<ndepth;i++) {
11285  // depth=3
11286  for (int i = 2; i < 3; i++) {
11287  TH1F *HEnegativedirectionRecosignal3 = (TH1F *)h2CeffHEnegativedirectionRecosignal3->Clone("twod1");
11288  float ccctest = 0; // to avoid empty massive elements
11289  for (int jphi = 0; jphi < nphi; jphi++) {
11290  double ccc1 = arecosignalhe[i][jeta][jphi];
11291  if (ccc1 != 0.) {
11292  HEnegativedirectionRecosignal3->Fill(jphi, ccc1);
11293  ccctest = 1.; //HEnegativedirectionRecosignal3->SetBinError(i,0.01);
11294  }
11295  } // for jphi
11296  if (ccctest > 0.) {
11297  //cout<<"666 kcountHEnegativedirectionRecosignal3 = "<<kcountHEnegativedirectionRecosignal3 <<" jeta-41= "<< jeta-41 <<endl;
11298  c3x5->cd(kcountHEnegativedirectionRecosignal3);
11299  HEnegativedirectionRecosignal3->SetMarkerStyle(20);
11300  HEnegativedirectionRecosignal3->SetMarkerSize(0.4);
11301  HEnegativedirectionRecosignal3->GetYaxis()->SetLabelSize(0.04);
11302  HEnegativedirectionRecosignal3->SetXTitle("HEnegativedirectionRecosignal3 \b");
11303  HEnegativedirectionRecosignal3->SetMarkerColor(2);
11304  HEnegativedirectionRecosignal3->SetLineColor(0);
11305  gPad->SetGridy();
11306  gPad->SetGridx();
11307  // gPad->SetLogy();
11308  if (kcountHEnegativedirectionRecosignal3 == 1)
11309  HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-29; depth = 3 \b");
11310  if (kcountHEnegativedirectionRecosignal3 == 2)
11311  HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-28; depth = 3 \b");
11312  if (kcountHEnegativedirectionRecosignal3 == 3)
11313  HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-27; depth = 3 \b");
11314  if (kcountHEnegativedirectionRecosignal3 == 4)
11315  HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-26; depth = 3 \b");
11316  if (kcountHEnegativedirectionRecosignal3 == 5)
11317  HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-25; depth = 3 \b");
11318  if (kcountHEnegativedirectionRecosignal3 == 6)
11319  HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-24; depth = 3 \b");
11320  if (kcountHEnegativedirectionRecosignal3 == 7)
11321  HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-23; depth = 3 \b");
11322  if (kcountHEnegativedirectionRecosignal3 == 8)
11323  HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-22; depth = 3 \b");
11324  if (kcountHEnegativedirectionRecosignal3 == 9)
11325  HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-21; depth = 3 \b");
11326  if (kcountHEnegativedirectionRecosignal3 == 10)
11327  HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-20; depth = 3 \b");
11328  if (kcountHEnegativedirectionRecosignal3 == 11)
11329  HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-19; depth = 3 \b");
11330  if (kcountHEnegativedirectionRecosignal3 == 12)
11331  HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-18; depth = 3 \b");
11332  if (kcountHEnegativedirectionRecosignal3 == 13)
11333  HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-17; depth = 3 \b");
11334  HEnegativedirectionRecosignal3->Draw("Error");
11335  kcountHEnegativedirectionRecosignal3++;
11336  if (kcountHEnegativedirectionRecosignal3 > 13)
11337  break; // 4x6 = 24
11338  } //ccctest>0
11339 
11340  } // for i
11341  } //if(jeta-41 < 0)
11342  } //for jeta
11344  c3x5->Update();
11345  c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth3HE.png");
11346  c3x5->Clear();
11347  // clean-up
11348  if (h2CeffHEnegativedirectionRecosignal3)
11349  delete h2CeffHEnegativedirectionRecosignal3;
11350  //========================================================================================== 1117
11351  //======================================================================
11352  //======================================================================1D plot: R vs phi , different eta, depth=4
11353  //cout<<" 1D plot: R vs phi , different eta, depth=4 *****" <<endl;
11354  c3x5->Clear();
11356  c3x5->Divide(3, 5);
11357  c3x5->cd(1);
11358  int kcountHEnegativedirectionRecosignal4 = 1;
11359  TH1F *h2CeffHEnegativedirectionRecosignal4 = new TH1F("h2CeffHEnegativedirectionRecosignal4", "", nphi, 0., 72.);
11360 
11361  for (int jeta = 0; jeta < njeta; jeta++) {
11362  // negativedirectionRecosignal:
11363  if (jeta - 41 < 0) {
11364  // for (int i=0;i<ndepth;i++) {
11365  // depth=4
11366  for (int i = 3; i < 4; i++) {
11367  TH1F *HEnegativedirectionRecosignal4 = (TH1F *)h2CeffHEnegativedirectionRecosignal4->Clone("twod1");
11368 
11369  float ccctest = 0; // to avoid empty massive elements
11370  for (int jphi = 0; jphi < nphi; jphi++) {
11371  double ccc1 = arecosignalhe[i][jeta][jphi];
11372  if (ccc1 != 0.) {
11373  HEnegativedirectionRecosignal4->Fill(jphi, ccc1);
11374  ccctest = 1.; //HEnegativedirectionRecosignal4->SetBinError(i,0.01);
11375  }
11376  } // for jphi
11377  if (ccctest > 0.) {
11378  //cout<<"777 kcountHEnegativedirectionRecosignal4 = "<<kcountHEnegativedirectionRecosignal4 <<" jeta-41= "<< jeta-41 <<endl;
11379  c3x5->cd(kcountHEnegativedirectionRecosignal4);
11380  HEnegativedirectionRecosignal4->SetMarkerStyle(20);
11381  HEnegativedirectionRecosignal4->SetMarkerSize(0.4);
11382  HEnegativedirectionRecosignal4->GetYaxis()->SetLabelSize(0.04);
11383  HEnegativedirectionRecosignal4->SetXTitle("HEnegativedirectionRecosignal4 \b");
11384  HEnegativedirectionRecosignal4->SetMarkerColor(2);
11385  HEnegativedirectionRecosignal4->SetLineColor(0);
11386  gPad->SetGridy();
11387  gPad->SetGridx();
11388  // gPad->SetLogy();
11389  if (kcountHEnegativedirectionRecosignal4 == 1)
11390  HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-28; depth = 4 \b");
11391  if (kcountHEnegativedirectionRecosignal4 == 2)
11392  HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-27; depth = 4 \b");
11393  if (kcountHEnegativedirectionRecosignal4 == 3)
11394  HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-26; depth = 4 \b");
11395  if (kcountHEnegativedirectionRecosignal4 == 4)
11396  HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-25; depth = 4 \b");
11397  if (kcountHEnegativedirectionRecosignal4 == 5)
11398  HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-24; depth = 4 \b");
11399  if (kcountHEnegativedirectionRecosignal4 == 6)
11400  HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-23; depth = 4 \b");
11401  if (kcountHEnegativedirectionRecosignal4 == 7)
11402  HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-22; depth = 4 \b");
11403  if (kcountHEnegativedirectionRecosignal4 == 8)
11404  HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-21; depth = 4 \b");
11405  if (kcountHEnegativedirectionRecosignal4 == 9)
11406  HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-20; depth = 4 \b");
11407  if (kcountHEnegativedirectionRecosignal4 == 10)
11408  HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-19; depth = 4 \b");
11409  if (kcountHEnegativedirectionRecosignal4 == 11)
11410  HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-18; depth = 4 \b");
11411  if (kcountHEnegativedirectionRecosignal4 == 12)
11412  HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-16; depth = 4 \b");
11413  HEnegativedirectionRecosignal4->Draw("Error");
11414  kcountHEnegativedirectionRecosignal4++;
11415  if (kcountHEnegativedirectionRecosignal4 > 12)
11416  break; // 4x6 = 24
11417  } //ccctest>0
11418 
11419  } // for i
11420  } //if(jeta-41 < 0)
11421  } //for jeta
11423  c3x5->Update();
11424  c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth4HE.png");
11425  c3x5->Clear();
11426  // clean-up
11427  if (h2CeffHEnegativedirectionRecosignal4)
11428  delete h2CeffHEnegativedirectionRecosignal4;
11429  //========================================================================================== 1118
11430  //======================================================================
11431  //======================================================================1D plot: R vs phi , different eta, depth=5
11432  //cout<<" 1D plot: R vs phi , different eta, depth=5 *****" <<endl;
11433  c3x5->Clear();
11435  c3x5->Divide(3, 5);
11436  c3x5->cd(1);
11437  int kcountHEnegativedirectionRecosignal5 = 1;
11438  TH1F *h2CeffHEnegativedirectionRecosignal5 = new TH1F("h2CeffHEnegativedirectionRecosignal5", "", nphi, 0., 72.);
11439 
11440  for (int jeta = 0; jeta < njeta; jeta++) {
11441  // negativedirectionRecosignal:
11442  if (jeta - 41 < 0) {
11443  // for (int i=0;i<ndepth;i++) {
11444  // depth=5
11445  for (int i = 4; i < 5; i++) {
11446  TH1F *HEnegativedirectionRecosignal5 = (TH1F *)h2CeffHEnegativedirectionRecosignal5->Clone("twod1");
11447 
11448  float ccctest = 0; // to avoid empty massive elements
11449  for (int jphi = 0; jphi < nphi; jphi++) {
11450  // cout<<"888 initial kcountHEnegativedirectionRecosignal5 = "<<kcountHEnegativedirectionRecosignal5 <<" jeta-41= "<< jeta-41 <<" jphi= "<< jphi <<" arecosignalhe[i][jeta][jphi]= "<< arecosignalhe[i][jeta][jphi] <<" depth= "<< i <<endl;
11451 
11452  double ccc1 = arecosignalhe[i][jeta][jphi];
11453  if (ccc1 != 0.) {
11454  HEnegativedirectionRecosignal5->Fill(jphi, ccc1);
11455  ccctest = 1.; //HEnegativedirectionRecosignal5->SetBinError(i,0.01);
11456  }
11457  } // for jphi
11458  if (ccctest > 0.) {
11459  //cout<<"888 kcountHEnegativedirectionRecosignal5 = "<<kcountHEnegativedirectionRecosignal5 <<" jeta-41= "<< jeta-41 <<endl;
11460  c3x5->cd(kcountHEnegativedirectionRecosignal5);
11461  HEnegativedirectionRecosignal5->SetMarkerStyle(20);
11462  HEnegativedirectionRecosignal5->SetMarkerSize(0.4);
11463  HEnegativedirectionRecosignal5->GetYaxis()->SetLabelSize(0.04);
11464  HEnegativedirectionRecosignal5->SetXTitle("HEnegativedirectionRecosignal5 \b");
11465  HEnegativedirectionRecosignal5->SetMarkerColor(2);
11466  HEnegativedirectionRecosignal5->SetLineColor(0);
11467  gPad->SetGridy();
11468  gPad->SetGridx();
11469  // gPad->SetLogy();
11470  if (kcountHEnegativedirectionRecosignal5 == 1)
11471  HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-28; depth = 5 \b");
11472  if (kcountHEnegativedirectionRecosignal5 == 2)
11473  HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-27; depth = 5 \b");
11474  if (kcountHEnegativedirectionRecosignal5 == 3)
11475  HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-26; depth = 5 \b");
11476  if (kcountHEnegativedirectionRecosignal5 == 4)
11477  HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-25; depth = 5 \b");
11478  if (kcountHEnegativedirectionRecosignal5 == 5)
11479  HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-24; depth = 5 \b");
11480  if (kcountHEnegativedirectionRecosignal5 == 6)
11481  HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-23; depth = 5 \b");
11482  if (kcountHEnegativedirectionRecosignal5 == 7)
11483  HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-22; depth = 5 \b");
11484  if (kcountHEnegativedirectionRecosignal5 == 8)
11485  HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-21; depth = 5 \b");
11486  if (kcountHEnegativedirectionRecosignal5 == 9)
11487  HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-20; depth = 5 \b");
11488  if (kcountHEnegativedirectionRecosignal5 == 10)
11489  HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-19; depth = 5 \b");
11490  if (kcountHEnegativedirectionRecosignal5 == 11)
11491  HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-18; depth = 5 \b");
11492  HEnegativedirectionRecosignal5->Draw("Error");
11493  kcountHEnegativedirectionRecosignal5++;
11494  if (kcountHEnegativedirectionRecosignal5 > 11)
11495  break; // 4x6 = 24
11496  } //ccctest>0
11497 
11498  } // for i
11499  } //if(jeta-41 < 0)
11500  } //for jeta
11502  c3x5->Update();
11503  c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth5HE.png");
11504  c3x5->Clear();
11505  // clean-up
11506  if (h2CeffHEnegativedirectionRecosignal5)
11507  delete h2CeffHEnegativedirectionRecosignal5;
11508  //========================================================================================== 1119
11509  //======================================================================
11510  //======================================================================1D plot: R vs phi , different eta, depth=6
11511  //cout<<" 1D plot: R vs phi , different eta, depth=6 *****" <<endl;
11512  c3x5->Clear();
11514  c3x5->Divide(3, 5);
11515  c3x5->cd(1);
11516  int kcountHEnegativedirectionRecosignal6 = 1;
11517  TH1F *h2CeffHEnegativedirectionRecosignal6 = new TH1F("h2CeffHEnegativedirectionRecosignal6", "", nphi, 0., 72.);
11518 
11519  for (int jeta = 0; jeta < njeta; jeta++) {
11520  // negativedirectionRecosignal:
11521  if (jeta - 41 < 0) {
11522  // for (int i=0;i<ndepth;i++) {
11523  // depth=6
11524  for (int i = 5; i < 6; i++) {
11525  TH1F *HEnegativedirectionRecosignal6 = (TH1F *)h2CeffHEnegativedirectionRecosignal6->Clone("twod1");
11526 
11527  float ccctest = 0; // to avoid empty massive elements
11528  for (int jphi = 0; jphi < nphi; jphi++) {
11529  double ccc1 = arecosignalhe[i][jeta][jphi];
11530  if (ccc1 != 0.) {
11531  HEnegativedirectionRecosignal6->Fill(jphi, ccc1);
11532  ccctest = 1.; //HEnegativedirectionRecosignal6->SetBinError(i,0.01);
11533  }
11534  } // for jphi
11535  if (ccctest > 0.) {
11536  //cout<<"999 kcountHEnegativedirectionRecosignal6 = "<<kcountHEnegativedirectionRecosignal6 <<" jeta-41= "<< jeta-41 <<endl;
11537  c3x5->cd(kcountHEnegativedirectionRecosignal6);
11538  HEnegativedirectionRecosignal6->SetMarkerStyle(20);
11539  HEnegativedirectionRecosignal6->SetMarkerSize(0.4);
11540  HEnegativedirectionRecosignal6->GetYaxis()->SetLabelSize(0.04);
11541  HEnegativedirectionRecosignal6->SetXTitle("HEnegativedirectionRecosignal6 \b");
11542  HEnegativedirectionRecosignal6->SetMarkerColor(2);
11543  HEnegativedirectionRecosignal6->SetLineColor(0);
11544  gPad->SetGridy();
11545  gPad->SetGridx();
11546  // gPad->SetLogy();
11547  if (kcountHEnegativedirectionRecosignal6 == 1)
11548  HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-28; depth = 6 \b");
11549  if (kcountHEnegativedirectionRecosignal6 == 2)
11550  HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-27; depth = 6 \b");
11551  if (kcountHEnegativedirectionRecosignal6 == 3)
11552  HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-26; depth = 6 \b");
11553  if (kcountHEnegativedirectionRecosignal6 == 4)
11554  HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-25; depth = 6 \b");
11555  if (kcountHEnegativedirectionRecosignal6 == 5)
11556  HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-24; depth = 6 \b");
11557  if (kcountHEnegativedirectionRecosignal6 == 6)
11558  HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-23; depth = 6 \b");
11559  if (kcountHEnegativedirectionRecosignal6 == 7)
11560  HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-22; depth = 6 \b");
11561  if (kcountHEnegativedirectionRecosignal6 == 8)
11562  HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-21; depth = 6 \b");
11563  if (kcountHEnegativedirectionRecosignal6 == 9)
11564  HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-20; depth = 6 \b");
11565  if (kcountHEnegativedirectionRecosignal6 == 10)
11566  HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-19; depth = 6 \b");
11567  HEnegativedirectionRecosignal6->Draw("Error");
11568  kcountHEnegativedirectionRecosignal6++;
11569  if (kcountHEnegativedirectionRecosignal6 > 10)
11570  break; // 4x6 = 24
11571  } //ccctest>0
11572 
11573  } // for i
11574  } //if(jeta-41 < 0)
11575  } //for jeta
11577  c3x5->Update();
11578  c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth6HE.png");
11579  c3x5->Clear();
11580  // clean-up
11581  if (h2CeffHEnegativedirectionRecosignal6)
11582  delete h2CeffHEnegativedirectionRecosignal6;
11583  //========================================================================================== 11110
11584  //======================================================================
11585  //======================================================================1D plot: R vs phi , different eta, depth=7
11586  //cout<<" 1D plot: R vs phi , different eta, depth=7 *****" <<endl;
11587  c3x5->Clear();
11589  c3x5->Divide(3, 5);
11590  c3x5->cd(1);
11591  int kcountHEnegativedirectionRecosignal7 = 1;
11592  TH1F *h2CeffHEnegativedirectionRecosignal7 = new TH1F("h2CeffHEnegativedirectionRecosignal7", "", nphi, 0., 72.);
11593 
11594  for (int jeta = 0; jeta < njeta; jeta++) {
11595  // negativedirectionRecosignal:
11596  if (jeta - 41 < 0) {
11597  // for (int i=0;i<ndepth;i++) {
11598  // depth=7
11599  for (int i = 6; i < 7; i++) {
11600  TH1F *HEnegativedirectionRecosignal7 = (TH1F *)h2CeffHEnegativedirectionRecosignal7->Clone("twod1");
11601 
11602  float ccctest = 0; // to avoid empty massive elements
11603  for (int jphi = 0; jphi < nphi; jphi++) {
11604  double ccc1 = arecosignalhe[i][jeta][jphi];
11605  if (ccc1 != 0.) {
11606  HEnegativedirectionRecosignal7->Fill(jphi, ccc1);
11607  ccctest = 1.; //HEnegativedirectionRecosignal7->SetBinError(i,0.01);
11608  }
11609  } // for jphi
11610  if (ccctest > 0.) {
11611  //cout<<"1010 kcountHEnegativedirectionRecosignal7 = "<<kcountHEnegativedirectionRecosignal7 <<" jeta-41= "<< jeta-41 <<endl;
11612  c3x5->cd(kcountHEnegativedirectionRecosignal7);
11613  HEnegativedirectionRecosignal7->SetMarkerStyle(20);
11614  HEnegativedirectionRecosignal7->SetMarkerSize(0.4);
11615  HEnegativedirectionRecosignal7->GetYaxis()->SetLabelSize(0.04);
11616  HEnegativedirectionRecosignal7->SetXTitle("HEnegativedirectionRecosignal7 \b");
11617  HEnegativedirectionRecosignal7->SetMarkerColor(2);
11618  HEnegativedirectionRecosignal7->SetLineColor(0);
11619  gPad->SetGridy();
11620  gPad->SetGridx();
11621  // gPad->SetLogy();
11622  if (kcountHEnegativedirectionRecosignal7 == 1)
11623  HEnegativedirectionRecosignal7->SetXTitle("R for HE- jeta =-28; depth = 7 \b");
11624  if (kcountHEnegativedirectionRecosignal7 == 2)
11625  HEnegativedirectionRecosignal7->SetXTitle("R for HE- jeta =-27; depth = 7 \b");
11626  if (kcountHEnegativedirectionRecosignal7 == 3)
11627  HEnegativedirectionRecosignal7->SetXTitle("R for HE- jeta =-26; depth = 7 \b");
11628  HEnegativedirectionRecosignal7->Draw("Error");
11629  kcountHEnegativedirectionRecosignal7++;
11630  if (kcountHEnegativedirectionRecosignal7 > 3)
11631  break; // 4x6 = 24
11632  } //ccctest>0
11633 
11634  } // for i
11635  } //if(jeta-41 < 0)
11636  } //for jeta
11638  c3x5->Update();
11639  c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth7HE.png");
11640  c3x5->Clear();
11641  // clean-up
11642  if (h2CeffHEnegativedirectionRecosignal7)
11643  delete h2CeffHEnegativedirectionRecosignal7;
11644 
11646 
11647  // DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD:
11648 
11649  //cout<<" Start Vaiance: preparation *****" <<endl;
11650  TH2F *recosignalVariance1HE1 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy2_HE1");
11651  TH2F *recosignalVariance0HE1 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HE1");
11652  TH2F *recosignalVarianceHE1 = (TH2F *)recosignalVariance1HE1->Clone("recosignalVarianceHE1");
11653  recosignalVarianceHE1->Divide(recosignalVariance1HE1, recosignalVariance0HE1, 1, 1, "B");
11654  TH2F *recosignalVariance1HE2 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy2_HE2");
11655  TH2F *recosignalVariance0HE2 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HE2");
11656  TH2F *recosignalVarianceHE2 = (TH2F *)recosignalVariance1HE2->Clone("recosignalVarianceHE2");
11657  recosignalVarianceHE2->Divide(recosignalVariance1HE2, recosignalVariance0HE2, 1, 1, "B");
11658  TH2F *recosignalVariance1HE3 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy2_HE3");
11659  TH2F *recosignalVariance0HE3 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HE3");
11660  TH2F *recosignalVarianceHE3 = (TH2F *)recosignalVariance1HE3->Clone("recosignalVarianceHE3");
11661  recosignalVarianceHE3->Divide(recosignalVariance1HE3, recosignalVariance0HE3, 1, 1, "B");
11662  TH2F *recosignalVariance1HE4 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy2_HE4");
11663  TH2F *recosignalVariance0HE4 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HE4");
11664  TH2F *recosignalVarianceHE4 = (TH2F *)recosignalVariance1HE4->Clone("recosignalVarianceHE4");
11665  recosignalVarianceHE4->Divide(recosignalVariance1HE4, recosignalVariance0HE4, 1, 1, "B");
11666  TH2F *recosignalVariance1HE5 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy2_HE5");
11667  TH2F *recosignalVariance0HE5 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HE5");
11668  TH2F *recosignalVarianceHE5 = (TH2F *)recosignalVariance1HE5->Clone("recosignalVarianceHE5");
11669  recosignalVarianceHE5->Divide(recosignalVariance1HE5, recosignalVariance0HE5, 1, 1, "B");
11670  TH2F *recosignalVariance1HE6 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy2_HE6");
11671  TH2F *recosignalVariance0HE6 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HE6");
11672  TH2F *recosignalVarianceHE6 = (TH2F *)recosignalVariance1HE6->Clone("recosignalVarianceHE6");
11673  recosignalVarianceHE6->Divide(recosignalVariance1HE6, recosignalVariance0HE6, 1, 1, "B");
11674  TH2F *recosignalVariance1HE7 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy2_HE7");
11675  TH2F *recosignalVariance0HE7 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HE7");
11676  TH2F *recosignalVarianceHE7 = (TH2F *)recosignalVariance1HE7->Clone("recosignalVarianceHE7");
11677  recosignalVarianceHE7->Divide(recosignalVariance1HE7, recosignalVariance0HE7, 1, 1, "B");
11678  //cout<<" Vaiance: preparation DONE *****" <<endl;
11679  //====================================================================== put Vaiance=Dispersia = Sig**2=<R**2> - (<R>)**2 into massive recosignalvariancehe
11680  // = sum(R*R)/N - (sum(R)/N)**2
11681  for (int jeta = 0; jeta < njeta; jeta++) {
11682  //preparation for PHI normalization:
11683  double sumrecosignalHE0 = 0;
11684  int nsumrecosignalHE0 = 0;
11685  double sumrecosignalHE1 = 0;
11686  int nsumrecosignalHE1 = 0;
11687  double sumrecosignalHE2 = 0;
11688  int nsumrecosignalHE2 = 0;
11689  double sumrecosignalHE3 = 0;
11690  int nsumrecosignalHE3 = 0;
11691  double sumrecosignalHE4 = 0;
11692  int nsumrecosignalHE4 = 0;
11693  double sumrecosignalHE5 = 0;
11694  int nsumrecosignalHE5 = 0;
11695  double sumrecosignalHE6 = 0;
11696  int nsumrecosignalHE6 = 0;
11697  for (int jphi = 0; jphi < njphi; jphi++) {
11698  recosignalvariancehe[0][jeta][jphi] = recosignalVarianceHE1->GetBinContent(jeta + 1, jphi + 1);
11699  recosignalvariancehe[1][jeta][jphi] = recosignalVarianceHE2->GetBinContent(jeta + 1, jphi + 1);
11700  recosignalvariancehe[2][jeta][jphi] = recosignalVarianceHE3->GetBinContent(jeta + 1, jphi + 1);
11701  recosignalvariancehe[3][jeta][jphi] = recosignalVarianceHE4->GetBinContent(jeta + 1, jphi + 1);
11702  recosignalvariancehe[4][jeta][jphi] = recosignalVarianceHE5->GetBinContent(jeta + 1, jphi + 1);
11703  recosignalvariancehe[5][jeta][jphi] = recosignalVarianceHE6->GetBinContent(jeta + 1, jphi + 1);
11704  recosignalvariancehe[6][jeta][jphi] = recosignalVarianceHE7->GetBinContent(jeta + 1, jphi + 1);
11705  if (recosignalvariancehe[0][jeta][jphi] > 0.) {
11706  sumrecosignalHE0 += recosignalvariancehe[0][jeta][jphi];
11707  ++nsumrecosignalHE0;
11708  }
11709  if (recosignalvariancehe[1][jeta][jphi] > 0.) {
11710  sumrecosignalHE1 += recosignalvariancehe[1][jeta][jphi];
11711  ++nsumrecosignalHE1;
11712  }
11713  if (recosignalvariancehe[2][jeta][jphi] > 0.) {
11714  sumrecosignalHE2 += recosignalvariancehe[2][jeta][jphi];
11715  ++nsumrecosignalHE2;
11716  }
11717  if (recosignalvariancehe[3][jeta][jphi] > 0.) {
11718  sumrecosignalHE3 += recosignalvariancehe[3][jeta][jphi];
11719  ++nsumrecosignalHE3;
11720  }
11721  if (recosignalvariancehe[4][jeta][jphi] > 0.) {
11722  sumrecosignalHE4 += recosignalvariancehe[4][jeta][jphi];
11723  ++nsumrecosignalHE4;
11724  }
11725  if (recosignalvariancehe[5][jeta][jphi] > 0.) {
11726  sumrecosignalHE5 += recosignalvariancehe[5][jeta][jphi];
11727  ++nsumrecosignalHE5;
11728  }
11729  if (recosignalvariancehe[6][jeta][jphi] > 0.) {
11730  sumrecosignalHE6 += recosignalvariancehe[6][jeta][jphi];
11731  ++nsumrecosignalHE6;
11732  }
11733  } // phi
11734  // PHI normalization :
11735  for (int jphi = 0; jphi < njphi; jphi++) {
11736  if (recosignalvariancehe[0][jeta][jphi] > 0.)
11737  recosignalvariancehe[0][jeta][jphi] /= (sumrecosignalHE0 / nsumrecosignalHE0);
11738  if (recosignalvariancehe[1][jeta][jphi] > 0.)
11739  recosignalvariancehe[1][jeta][jphi] /= (sumrecosignalHE1 / nsumrecosignalHE1);
11740  if (recosignalvariancehe[2][jeta][jphi] > 0.)
11741  recosignalvariancehe[2][jeta][jphi] /= (sumrecosignalHE2 / nsumrecosignalHE2);
11742  if (recosignalvariancehe[3][jeta][jphi] > 0.)
11743  recosignalvariancehe[3][jeta][jphi] /= (sumrecosignalHE3 / nsumrecosignalHE3);
11744  if (recosignalvariancehe[4][jeta][jphi] > 0.)
11745  recosignalvariancehe[4][jeta][jphi] /= (sumrecosignalHE4 / nsumrecosignalHE4);
11746  if (recosignalvariancehe[5][jeta][jphi] > 0.)
11747  recosignalvariancehe[5][jeta][jphi] /= (sumrecosignalHE5 / nsumrecosignalHE5);
11748  if (recosignalvariancehe[6][jeta][jphi] > 0.)
11749  recosignalvariancehe[6][jeta][jphi] /= (sumrecosignalHE6 / nsumrecosignalHE6);
11750  } // phi
11751  // recosignalvariancehe (D) = sum(R*R)/N - (sum(R)/N)**2
11752  for (int jphi = 0; jphi < njphi; jphi++) {
11753  // cout<<"12 12 12 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
11754  recosignalvariancehe[0][jeta][jphi] -= arecosignalhe[0][jeta][jphi] * arecosignalhe[0][jeta][jphi];
11755  recosignalvariancehe[0][jeta][jphi] = fabs(recosignalvariancehe[0][jeta][jphi]);
11756  recosignalvariancehe[1][jeta][jphi] -= arecosignalhe[1][jeta][jphi] * arecosignalhe[1][jeta][jphi];
11757  recosignalvariancehe[1][jeta][jphi] = fabs(recosignalvariancehe[1][jeta][jphi]);
11758  recosignalvariancehe[2][jeta][jphi] -= arecosignalhe[2][jeta][jphi] * arecosignalhe[2][jeta][jphi];
11759  recosignalvariancehe[2][jeta][jphi] = fabs(recosignalvariancehe[2][jeta][jphi]);
11760  recosignalvariancehe[3][jeta][jphi] -= arecosignalhe[3][jeta][jphi] * arecosignalhe[3][jeta][jphi];
11761  recosignalvariancehe[3][jeta][jphi] = fabs(recosignalvariancehe[3][jeta][jphi]);
11762  recosignalvariancehe[4][jeta][jphi] -= arecosignalhe[4][jeta][jphi] * arecosignalhe[4][jeta][jphi];
11763  recosignalvariancehe[4][jeta][jphi] = fabs(recosignalvariancehe[4][jeta][jphi]);
11764  recosignalvariancehe[5][jeta][jphi] -= arecosignalhe[5][jeta][jphi] * arecosignalhe[5][jeta][jphi];
11765  recosignalvariancehe[5][jeta][jphi] = fabs(recosignalvariancehe[5][jeta][jphi]);
11766  recosignalvariancehe[6][jeta][jphi] -= arecosignalhe[6][jeta][jphi] * arecosignalhe[6][jeta][jphi];
11767  recosignalvariancehe[6][jeta][jphi] = fabs(recosignalvariancehe[6][jeta][jphi]);
11768  }
11769  }
11770  //cout<<" Vaiance: DONE*****" <<endl;
11771  //------------------------ 2D-eta/phi-plot: D, averaged over depthes
11772  //======================================================================
11773  //======================================================================
11774  //cout<<" R2D-eta/phi-plot: D, averaged over depthes *****" <<endl;
11775  c1x1->Clear();
11777  c1x0->Divide(1, 1);
11778  c1x0->cd(1);
11779  TH2F *DefzDrecosignalHE42D = new TH2F("DefzDrecosignalHE42D", "", neta, -41., 41., nphi, 0., 72.);
11780  TH2F *DefzDrecosignalHE42D0 = new TH2F("DefzDrecosignalHE42D0", "", neta, -41., 41., nphi, 0., 72.);
11781  TH2F *DefzDrecosignalHE42DF = (TH2F *)DefzDrecosignalHE42D0->Clone("DefzDrecosignalHE42DF");
11782  for (int i = 0; i < ndepth; i++) {
11783  for (int jeta = 0; jeta < neta; jeta++) {
11784  for (int jphi = 0; jphi < nphi; jphi++) {
11785  double ccc1 = recosignalvariancehe[i][jeta][jphi];
11786  int k2plot = jeta - 41;
11787  int kkk = k2plot; //if(k2plot >0 kkk=k2plot+1; //-41 +41 !=0
11788  if (arecosignalhe[i][jeta][jphi] > 0.) {
11789  DefzDrecosignalHE42D->Fill(kkk, jphi, ccc1);
11790  DefzDrecosignalHE42D0->Fill(kkk, jphi, 1.);
11791  }
11792  }
11793  }
11794  }
11795  DefzDrecosignalHE42DF->Divide(DefzDrecosignalHE42D, DefzDrecosignalHE42D0, 1, 1, "B"); // average A
11796  // DefzDrecosignalHE1->Sumw2();
11797  gPad->SetGridy();
11798  gPad->SetGridx(); // gPad->SetLogz();
11799  DefzDrecosignalHE42DF->SetMarkerStyle(20);
11800  DefzDrecosignalHE42DF->SetMarkerSize(0.4);
11801  DefzDrecosignalHE42DF->GetZaxis()->SetLabelSize(0.08);
11802  DefzDrecosignalHE42DF->SetXTitle("<D>_depth #eta \b");
11803  DefzDrecosignalHE42DF->SetYTitle(" #phi \b");
11804  DefzDrecosignalHE42DF->SetZTitle("<D>_depth \b");
11805  DefzDrecosignalHE42DF->SetMarkerColor(2);
11806  DefzDrecosignalHE42DF->SetLineColor(
11807  0); // DefzDrecosignalHE42DF->SetMaximum(1.000); // DefzDrecosignalHE42DF->SetMinimum(1.0);
11808  DefzDrecosignalHE42DF->Draw("COLZ");
11810  c1x0->Update();
11811  c1x0->Print("DrecosignalGeneralD2PhiSymmetryHE.png");
11812  c1x0->Clear();
11813  // clean-up
11814  if (DefzDrecosignalHE42D)
11815  delete DefzDrecosignalHE42D;
11816  if (DefzDrecosignalHE42D0)
11817  delete DefzDrecosignalHE42D0;
11818  if (DefzDrecosignalHE42DF)
11819  delete DefzDrecosignalHE42DF;
11820  //====================================================================== 1D plot: D vs phi , averaged over depthes & eta
11821  //======================================================================
11822  //cout<<" 1D plot: D vs phi , averaged over depthes & eta *****" <<endl;
11823  c1x1->Clear();
11825  c1x1->Divide(1, 1);
11826  c1x1->cd(1);
11827  TH1F *DefzDrecosignalHE41D = new TH1F("DefzDrecosignalHE41D", "", nphi, 0., 72.);
11828  TH1F *DefzDrecosignalHE41D0 = new TH1F("DefzDrecosignalHE41D0", "", nphi, 0., 72.);
11829  TH1F *DefzDrecosignalHE41DF = (TH1F *)DefzDrecosignalHE41D0->Clone("DefzDrecosignalHE41DF");
11830 
11831  for (int jphi = 0; jphi < nphi; jphi++) {
11832  for (int jeta = 0; jeta < neta; jeta++) {
11833  for (int i = 0; i < ndepth; i++) {
11834  double ccc1 = recosignalvariancehe[i][jeta][jphi];
11835  if (arecosignalhe[i][jeta][jphi] > 0.) {
11836  DefzDrecosignalHE41D->Fill(jphi, ccc1);
11837  DefzDrecosignalHE41D0->Fill(jphi, 1.);
11838  }
11839  }
11840  }
11841  }
11842  // DefzDrecosignalHE41D->Sumw2();DefzDrecosignalHE41D0->Sumw2();
11843 
11844  DefzDrecosignalHE41DF->Divide(
11845  DefzDrecosignalHE41D, DefzDrecosignalHE41D0, 1, 1, "B"); // R averaged over depthes & eta
11846  DefzDrecosignalHE41D0->Sumw2();
11847  // for (int jphi=1;jphi<73;jphi++) {DefzDrecosignalHE41DF->SetBinError(jphi,0.01);}
11848  gPad->SetGridy();
11849  gPad->SetGridx(); // gPad->SetLogz();
11850  DefzDrecosignalHE41DF->SetMarkerStyle(20);
11851  DefzDrecosignalHE41DF->SetMarkerSize(1.4);
11852  DefzDrecosignalHE41DF->GetZaxis()->SetLabelSize(0.08);
11853  DefzDrecosignalHE41DF->SetXTitle("#phi \b");
11854  DefzDrecosignalHE41DF->SetYTitle(" <D> \b");
11855  DefzDrecosignalHE41DF->SetZTitle("<D>_PHI - AllDepthes \b");
11856  DefzDrecosignalHE41DF->SetMarkerColor(4);
11857  DefzDrecosignalHE41DF->SetLineColor(
11858  4); // DefzDrecosignalHE41DF->SetMinimum(0.8); DefzDrecosignalHE41DF->SetMinimum(-0.015);
11859  DefzDrecosignalHE41DF->Draw("Error");
11861  c1x1->Update();
11862  c1x1->Print("DrecosignalGeneralD1PhiSymmetryHE.png");
11863  c1x1->Clear();
11864  // clean-up
11865  if (DefzDrecosignalHE41D)
11866  delete DefzDrecosignalHE41D;
11867  if (DefzDrecosignalHE41D0)
11868  delete DefzDrecosignalHE41D0;
11869  if (DefzDrecosignalHE41DF)
11870  delete DefzDrecosignalHE41DF;
11871  //========================================================================================== 14
11872  //======================================================================
11873  //======================================================================1D plot: D vs phi , different eta, depth=1
11874  //cout<<" 1D plot: D vs phi , different eta, depth=1 *****" <<endl;
11875  c3x5->Clear();
11877  c3x5->Divide(3, 5);
11878  c3x5->cd(1);
11879  int kcountHEpositivedirectionRecosignalD1 = 1;
11880  TH1F *h2CeffHEpositivedirectionRecosignalD1 = new TH1F("h2CeffHEpositivedirectionRecosignalD1", "", nphi, 0., 72.);
11881 
11882  for (int jeta = 0; jeta < njeta; jeta++) {
11883  // positivedirectionRecosignalD:
11884  if (jeta - 41 >= 0) {
11885  // for (int i=0;i<ndepth;i++) {
11886  // depth=1
11887  for (int i = 0; i < 1; i++) {
11888  TH1F *HEpositivedirectionRecosignalD1 = (TH1F *)h2CeffHEpositivedirectionRecosignalD1->Clone("twod1");
11889 
11890  float ccctest = 0; // to avoid empty massive elements
11891  for (int jphi = 0; jphi < nphi; jphi++) {
11892  double ccc1 = recosignalvariancehe[i][jeta][jphi];
11893  if (arecosignalhe[i][jeta][jphi] > 0.) {
11894  HEpositivedirectionRecosignalD1->Fill(jphi, ccc1);
11895  ccctest = 1.; //HEpositivedirectionRecosignalD1->SetBinError(i,0.01);
11896  }
11897  } // for jphi
11898  if (ccctest > 0.) {
11899  //cout<<"1414 kcountHEpositivedirectionRecosignalD1 = "<<kcountHEpositivedirectionRecosignalD1 <<" jeta-41= "<< jeta-41 <<endl;
11900  c3x5->cd(kcountHEpositivedirectionRecosignalD1);
11901  HEpositivedirectionRecosignalD1->SetMarkerStyle(20);
11902  HEpositivedirectionRecosignalD1->SetMarkerSize(0.4);
11903  HEpositivedirectionRecosignalD1->GetYaxis()->SetLabelSize(0.04);
11904  HEpositivedirectionRecosignalD1->SetXTitle("HEpositivedirectionRecosignalD1 \b");
11905  HEpositivedirectionRecosignalD1->SetMarkerColor(2);
11906  HEpositivedirectionRecosignalD1->SetLineColor(0);
11907  gPad->SetGridy();
11908  gPad->SetGridx();
11909  // gPad->SetLogy();
11910  if (kcountHEpositivedirectionRecosignalD1 == 1)
11911  HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 17; depth = 1 \b");
11912  if (kcountHEpositivedirectionRecosignalD1 == 2)
11913  HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 18; depth = 1 \b");
11914  if (kcountHEpositivedirectionRecosignalD1 == 3)
11915  HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 19; depth = 1 \b");
11916  if (kcountHEpositivedirectionRecosignalD1 == 4)
11917  HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 20; depth = 1 \b");
11918  if (kcountHEpositivedirectionRecosignalD1 == 5)
11919  HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 21; depth = 1 \b");
11920  if (kcountHEpositivedirectionRecosignalD1 == 6)
11921  HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 22; depth = 1 \b");
11922  if (kcountHEpositivedirectionRecosignalD1 == 7)
11923  HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 23; depth = 1 \b");
11924  if (kcountHEpositivedirectionRecosignalD1 == 8)
11925  HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 24; depth = 1 \b");
11926  if (kcountHEpositivedirectionRecosignalD1 == 9)
11927  HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 25; depth = 1 \b");
11928  if (kcountHEpositivedirectionRecosignalD1 == 10)
11929  HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 26; depth = 1 \b");
11930  if (kcountHEpositivedirectionRecosignalD1 == 11)
11931  HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 27; depth = 1 \b");
11932  if (kcountHEpositivedirectionRecosignalD1 == 12)
11933  HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 28; depth = 1 \b");
11934  HEpositivedirectionRecosignalD1->Draw("Error");
11935  kcountHEpositivedirectionRecosignalD1++;
11936  if (kcountHEpositivedirectionRecosignalD1 > 12)
11937  break; // 4x6 = 24
11938  } //ccctest>0
11939 
11940  } // for i
11941  } //if(jeta-41 >= 0)
11942  } //for jeta
11944  c3x5->Update();
11945  c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth1HE.png");
11946  c3x5->Clear();
11947  // clean-up
11948  if (h2CeffHEpositivedirectionRecosignalD1)
11949  delete h2CeffHEpositivedirectionRecosignalD1;
11950  //========================================================================================== 15
11951  //======================================================================
11952  //======================================================================1D plot: D vs phi , different eta, depth=2
11953  //cout<<" 1D plot: D vs phi , different eta, depth=2 *****" <<endl;
11954  c3x5->Clear();
11955  c3x5->Divide(3, 5);
11956  c3x5->cd(1);
11957  int kcountHEpositivedirectionRecosignalD2 = 1;
11958  TH1F *h2CeffHEpositivedirectionRecosignalD2 = new TH1F("h2CeffHEpositivedirectionRecosignalD2", "", nphi, 0., 72.);
11959 
11960  for (int jeta = 0; jeta < njeta; jeta++) {
11961  // positivedirectionRecosignalD:
11962  if (jeta - 41 >= 0) {
11963  // for (int i=0;i<ndepth;i++) {
11964  // depth=2
11965  for (int i = 1; i < 2; i++) {
11966  TH1F *HEpositivedirectionRecosignalD2 = (TH1F *)h2CeffHEpositivedirectionRecosignalD2->Clone("twod1");
11967 
11968  float ccctest = 0; // to avoid empty massive elements
11969  for (int jphi = 0; jphi < nphi; jphi++) {
11970  double ccc1 = recosignalvariancehe[i][jeta][jphi];
11971  if (arecosignalhe[i][jeta][jphi] > 0.) {
11972  HEpositivedirectionRecosignalD2->Fill(jphi, ccc1);
11973  ccctest = 1.; //HEpositivedirectionRecosignalD2->SetBinError(i,0.01);
11974  }
11975  } // for jphi
11976  if (ccctest > 0.) {
11977  //cout<<"1515 kcountHEpositivedirectionRecosignalD2 = "<<kcountHEpositivedirectionRecosignalD2 <<" jeta-41= "<< jeta-41 <<endl;
11978  c3x5->cd(kcountHEpositivedirectionRecosignalD2);
11979  HEpositivedirectionRecosignalD2->SetMarkerStyle(20);
11980  HEpositivedirectionRecosignalD2->SetMarkerSize(0.4);
11981  HEpositivedirectionRecosignalD2->GetYaxis()->SetLabelSize(0.04);
11982  HEpositivedirectionRecosignalD2->SetXTitle("HEpositivedirectionRecosignalD2 \b");
11983  HEpositivedirectionRecosignalD2->SetMarkerColor(2);
11984  HEpositivedirectionRecosignalD2->SetLineColor(0);
11985  gPad->SetGridy();
11986  gPad->SetGridx();
11987  // gPad->SetLogy();
11988  if (kcountHEpositivedirectionRecosignalD2 == 1)
11989  HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 16; depth = 2 \b");
11990  if (kcountHEpositivedirectionRecosignalD2 == 2)
11991  HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 17; depth = 2 \b");
11992  if (kcountHEpositivedirectionRecosignalD2 == 3)
11993  HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 18; depth = 2 \b");
11994  if (kcountHEpositivedirectionRecosignalD2 == 4)
11995  HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 19; depth = 2 \b");
11996  if (kcountHEpositivedirectionRecosignalD2 == 5)
11997  HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 20; depth = 2 \b");
11998  if (kcountHEpositivedirectionRecosignalD2 == 6)
11999  HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 21; depth = 2 \b");
12000  if (kcountHEpositivedirectionRecosignalD2 == 7)
12001  HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 22; depth = 2 \b");
12002  if (kcountHEpositivedirectionRecosignalD2 == 8)
12003  HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 23; depth = 2 \b");
12004  if (kcountHEpositivedirectionRecosignalD2 == 9)
12005  HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 24; depth = 2 \b");
12006  if (kcountHEpositivedirectionRecosignalD2 == 10)
12007  HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 25; depth = 2 \b");
12008  if (kcountHEpositivedirectionRecosignalD2 == 11)
12009  HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 26; depth = 2 \b");
12010  if (kcountHEpositivedirectionRecosignalD2 == 12)
12011  HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 27; depth = 2 \b");
12012  if (kcountHEpositivedirectionRecosignalD2 == 13)
12013  HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 28; depth = 2 \b");
12014  HEpositivedirectionRecosignalD2->Draw("Error");
12015  kcountHEpositivedirectionRecosignalD2++;
12016  if (kcountHEpositivedirectionRecosignalD2 > 13)
12017  break; // 4x6 = 24
12018  } //ccctest>0
12019 
12020  } // for i
12021  } //if(jeta-41 >= 0)
12022  } //for jeta
12024  c3x5->Update();
12025  c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth2HE.png");
12026  c3x5->Clear();
12027  // clean-up
12028  if (h2CeffHEpositivedirectionRecosignalD2)
12029  delete h2CeffHEpositivedirectionRecosignalD2;
12030  //========================================================================================== 16
12031  //======================================================================
12032  //======================================================================1D plot: D vs phi , different eta, depth=3
12033  //cout<<" 1D plot: D vs phi , different eta, depth=3 *****" <<endl;
12034  c3x5->Clear();
12035  c3x5->Divide(3, 5);
12036  c3x5->cd(1);
12037  int kcountHEpositivedirectionRecosignalD3 = 1;
12038  TH1F *h2CeffHEpositivedirectionRecosignalD3 = new TH1F("h2CeffHEpositivedirectionRecosignalD3", "", nphi, 0., 72.);
12039 
12040  for (int jeta = 0; jeta < njeta; jeta++) {
12041  // positivedirectionRecosignalD:
12042  if (jeta - 41 >= 0) {
12043  // for (int i=0;i<ndepth;i++) {
12044  // depth=3
12045  for (int i = 2; i < 3; i++) {
12046  TH1F *HEpositivedirectionRecosignalD3 = (TH1F *)h2CeffHEpositivedirectionRecosignalD3->Clone("twod1");
12047 
12048  float ccctest = 0; // to avoid empty massive elements
12049  for (int jphi = 0; jphi < nphi; jphi++) {
12050  double ccc1 = recosignalvariancehe[i][jeta][jphi];
12051  if (arecosignalhe[i][jeta][jphi] > 0.) {
12052  HEpositivedirectionRecosignalD3->Fill(jphi, ccc1);
12053  ccctest = 1.; //HEpositivedirectionRecosignalD3->SetBinError(i,0.01);
12054  }
12055  } // for jphi
12056  if (ccctest > 0.) {
12057  //cout<<"1616 kcountHEpositivedirectionRecosignalD3 = "<<kcountHEpositivedirectionRecosignalD3 <<" jeta-41= "<< jeta-41 <<endl;
12058  c3x5->cd(kcountHEpositivedirectionRecosignalD3);
12059  HEpositivedirectionRecosignalD3->SetMarkerStyle(20);
12060  HEpositivedirectionRecosignalD3->SetMarkerSize(0.4);
12061  HEpositivedirectionRecosignalD3->GetYaxis()->SetLabelSize(0.04);
12062  HEpositivedirectionRecosignalD3->SetXTitle("HEpositivedirectionRecosignalD3 \b");
12063  HEpositivedirectionRecosignalD3->SetMarkerColor(2);
12064  HEpositivedirectionRecosignalD3->SetLineColor(0);
12065  gPad->SetGridy();
12066  gPad->SetGridx();
12067  // gPad->SetLogy();
12068  if (kcountHEpositivedirectionRecosignalD3 == 1)
12069  HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 16; depth = 3 \b");
12070  if (kcountHEpositivedirectionRecosignalD3 == 2)
12071  HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 17; depth = 3 \b");
12072  if (kcountHEpositivedirectionRecosignalD3 == 3)
12073  HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 18; depth = 3 \b");
12074  if (kcountHEpositivedirectionRecosignalD3 == 4)
12075  HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 19; depth = 3 \b");
12076  if (kcountHEpositivedirectionRecosignalD3 == 5)
12077  HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 20; depth = 3 \b");
12078  if (kcountHEpositivedirectionRecosignalD3 == 6)
12079  HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 21; depth = 3 \b");
12080  if (kcountHEpositivedirectionRecosignalD3 == 7)
12081  HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 22; depth = 3 \b");
12082  if (kcountHEpositivedirectionRecosignalD3 == 8)
12083  HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 23; depth = 3 \b");
12084  if (kcountHEpositivedirectionRecosignalD3 == 9)
12085  HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 24; depth = 3 \b");
12086  if (kcountHEpositivedirectionRecosignalD3 == 10)
12087  HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 25; depth = 3 \b");
12088  if (kcountHEpositivedirectionRecosignalD3 == 11)
12089  HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 26; depth = 3 \b");
12090  if (kcountHEpositivedirectionRecosignalD3 == 12)
12091  HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 27; depth = 3 \b");
12092  if (kcountHEpositivedirectionRecosignalD3 == 13)
12093  HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 28; depth = 3 \b");
12094  HEpositivedirectionRecosignalD3->Draw("Error");
12095  kcountHEpositivedirectionRecosignalD3++;
12096  if (kcountHEpositivedirectionRecosignalD3 > 13)
12097  break; // 4x6 = 24
12098  } //ccctest>0
12099 
12100  } // for i
12101  } //if(jeta-41 >= 0)
12102  } //for jeta
12104  c3x5->Update();
12105  c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth3HE.png");
12106  c3x5->Clear();
12107  // clean-up
12108  if (h2CeffHEpositivedirectionRecosignalD3)
12109  delete h2CeffHEpositivedirectionRecosignalD3;
12110  //========================================================================================== 17
12111  //======================================================================
12112  //======================================================================1D plot: D vs phi , different eta, depth=4
12113  //cout<<" 1D plot: D vs phi , different eta, depth=4 *****" <<endl;
12114  c3x5->Clear();
12115  c3x5->Divide(3, 5);
12116  c3x5->cd(1);
12117  int kcountHEpositivedirectionRecosignalD4 = 1;
12118  TH1F *h2CeffHEpositivedirectionRecosignalD4 = new TH1F("h2CeffHEpositivedirectionRecosignalD4", "", nphi, 0., 72.);
12119 
12120  for (int jeta = 0; jeta < njeta; jeta++) {
12121  // positivedirectionRecosignalD:
12122  if (jeta - 41 >= 0) {
12123  // for (int i=0;i<ndepth;i++) {
12124  // depth=4
12125  for (int i = 3; i < 4; i++) {
12126  TH1F *HEpositivedirectionRecosignalD4 = (TH1F *)h2CeffHEpositivedirectionRecosignalD4->Clone("twod1");
12127 
12128  float ccctest = 0; // to avoid empty massive elements
12129  for (int jphi = 0; jphi < nphi; jphi++) {
12130  double ccc1 = recosignalvariancehe[i][jeta][jphi];
12131  if (arecosignalhe[i][jeta][jphi] > 0.) {
12132  HEpositivedirectionRecosignalD4->Fill(jphi, ccc1);
12133  ccctest = 1.; //HEpositivedirectionRecosignalD4->SetBinError(i,0.01);
12134  }
12135  } // for jphi
12136  if (ccctest > 0.) {
12137  //cout<<"1717 kcountHEpositivedirectionRecosignalD4 = "<<kcountHEpositivedirectionRecosignalD4 <<" jeta-41= "<< jeta-41 <<endl;
12138  c3x5->cd(kcountHEpositivedirectionRecosignalD4);
12139  HEpositivedirectionRecosignalD4->SetMarkerStyle(20);
12140  HEpositivedirectionRecosignalD4->SetMarkerSize(0.4);
12141  HEpositivedirectionRecosignalD4->GetYaxis()->SetLabelSize(0.04);
12142  HEpositivedirectionRecosignalD4->SetXTitle("HEpositivedirectionRecosignalD4 \b");
12143  HEpositivedirectionRecosignalD4->SetMarkerColor(2);
12144  HEpositivedirectionRecosignalD4->SetLineColor(0);
12145  gPad->SetGridy();
12146  gPad->SetGridx();
12147  // gPad->SetLogy();
12148  if (kcountHEpositivedirectionRecosignalD4 == 1)
12149  HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 15; depth = 4 \b");
12150  if (kcountHEpositivedirectionRecosignalD4 == 2)
12151  HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 17; depth = 4 \b");
12152  if (kcountHEpositivedirectionRecosignalD4 == 3)
12153  HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 18; depth = 4 \b");
12154  if (kcountHEpositivedirectionRecosignalD4 == 4)
12155  HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 19; depth = 4 \b");
12156  if (kcountHEpositivedirectionRecosignalD4 == 5)
12157  HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 20; depth = 4 \b");
12158  if (kcountHEpositivedirectionRecosignalD4 == 6)
12159  HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 21; depth = 4 \b");
12160  if (kcountHEpositivedirectionRecosignalD4 == 7)
12161  HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 22; depth = 4 \b");
12162  if (kcountHEpositivedirectionRecosignalD4 == 8)
12163  HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 23; depth = 4 \b");
12164  if (kcountHEpositivedirectionRecosignalD4 == 9)
12165  HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 24; depth = 4 \b");
12166  if (kcountHEpositivedirectionRecosignalD4 == 10)
12167  HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 25; depth = 4 \b");
12168  if (kcountHEpositivedirectionRecosignalD4 == 11)
12169  HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 26; depth = 4 \b");
12170  if (kcountHEpositivedirectionRecosignalD4 == 12)
12171  HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 27; depth = 4 \b");
12172  HEpositivedirectionRecosignalD4->Draw("Error");
12173  kcountHEpositivedirectionRecosignalD4++;
12174  if (kcountHEpositivedirectionRecosignalD4 > 12)
12175  break; // 4x6 = 24
12176  } //ccctest>0
12177 
12178  } // for i
12179  } //if(jeta-41 >= 0)
12180  } //for jeta
12182  c3x5->Update();
12183  c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth4HE.png");
12184  c3x5->Clear();
12185  // clean-up
12186  if (h2CeffHEpositivedirectionRecosignalD4)
12187  delete h2CeffHEpositivedirectionRecosignalD4;
12188  //========================================================================================== 18
12189  //======================================================================
12190  //======================================================================1D plot: D vs phi , different eta, depth=5
12191  //cout<<" 1D plot: D vs phi , different eta, depth=5 *****" <<endl;
12192  c3x5->Clear();
12193  c3x5->Divide(3, 5);
12194  c3x5->cd(1);
12195  int kcountHEpositivedirectionRecosignalD5 = 1;
12196  TH1F *h2CeffHEpositivedirectionRecosignalD5 = new TH1F("h2CeffHEpositivedirectionRecosignalD5", "", nphi, 0., 72.);
12197 
12198  for (int jeta = 0; jeta < njeta; jeta++) {
12199  // positivedirectionRecosignalD:
12200  if (jeta - 41 >= 0) {
12201  // for (int i=0;i<ndepth;i++) {
12202  // depth=5
12203  for (int i = 4; i < 5; i++) {
12204  TH1F *HEpositivedirectionRecosignalD5 = (TH1F *)h2CeffHEpositivedirectionRecosignalD5->Clone("twod1");
12205 
12206  float ccctest = 0; // to avoid empty massive elements
12207  for (int jphi = 0; jphi < nphi; jphi++) {
12208  double ccc1 = recosignalvariancehe[i][jeta][jphi];
12209  if (arecosignalhe[i][jeta][jphi] > 0.) {
12210  HEpositivedirectionRecosignalD5->Fill(jphi, ccc1);
12211  ccctest = 1.; //HEpositivedirectionRecosignalD5->SetBinError(i,0.01);
12212  }
12213  } // for jphi
12214  if (ccctest > 0.) {
12215  //cout<<"1818 kcountHEpositivedirectionRecosignalD5 = "<<kcountHEpositivedirectionRecosignalD5 <<" jeta-41= "<< jeta-41 <<endl;
12216  c3x5->cd(kcountHEpositivedirectionRecosignalD5);
12217  HEpositivedirectionRecosignalD5->SetMarkerStyle(20);
12218  HEpositivedirectionRecosignalD5->SetMarkerSize(0.4);
12219  HEpositivedirectionRecosignalD5->GetYaxis()->SetLabelSize(0.04);
12220  HEpositivedirectionRecosignalD5->SetXTitle("HEpositivedirectionRecosignalD5 \b");
12221  HEpositivedirectionRecosignalD5->SetMarkerColor(2);
12222  HEpositivedirectionRecosignalD5->SetLineColor(0);
12223  gPad->SetGridy();
12224  gPad->SetGridx();
12225  // gPad->SetLogy();
12226  if (kcountHEpositivedirectionRecosignalD5 == 1)
12227  HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 17; depth = 5 \b");
12228  if (kcountHEpositivedirectionRecosignalD5 == 2)
12229  HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 18; depth = 5 \b");
12230  if (kcountHEpositivedirectionRecosignalD5 == 3)
12231  HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 19; depth = 5 \b");
12232  if (kcountHEpositivedirectionRecosignalD5 == 4)
12233  HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 20; depth = 5 \b");
12234  if (kcountHEpositivedirectionRecosignalD5 == 5)
12235  HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 21; depth = 5 \b");
12236  if (kcountHEpositivedirectionRecosignalD5 == 6)
12237  HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 22; depth = 5 \b");
12238  if (kcountHEpositivedirectionRecosignalD5 == 7)
12239  HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 23; depth = 5 \b");
12240  if (kcountHEpositivedirectionRecosignalD5 == 8)
12241  HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 24; depth = 5 \b");
12242  if (kcountHEpositivedirectionRecosignalD5 == 9)
12243  HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 25; depth = 5 \b");
12244  if (kcountHEpositivedirectionRecosignalD5 == 10)
12245  HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 26; depth = 5 \b");
12246  if (kcountHEpositivedirectionRecosignalD5 == 11)
12247  HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 27; depth = 5 \b");
12248  HEpositivedirectionRecosignalD5->Draw("Error");
12249  kcountHEpositivedirectionRecosignalD5++;
12250  if (kcountHEpositivedirectionRecosignalD5 > 11)
12251  break; // 4x6 = 24
12252  } //ccctest>0
12253 
12254  } // for i
12255  } //if(jeta-41 >= 0)
12256  } //for jeta
12258  c3x5->Update();
12259  c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth5HE.png");
12260  c3x5->Clear();
12261  // clean-up
12262  if (h2CeffHEpositivedirectionRecosignalD5)
12263  delete h2CeffHEpositivedirectionRecosignalD5;
12264  //========================================================================================== 19
12265  //======================================================================
12266  //======================================================================1D plot: D vs phi , different eta, depth=6
12267  //cout<<" 1D plot: D vs phi , different eta, depth=6 *****" <<endl;
12268  c3x5->Clear();
12269  c3x5->Divide(3, 5);
12270  c3x5->cd(1);
12271  int kcountHEpositivedirectionRecosignalD6 = 1;
12272  TH1F *h2CeffHEpositivedirectionRecosignalD6 = new TH1F("h2CeffHEpositivedirectionRecosignalD6", "", nphi, 0., 72.);
12273 
12274  for (int jeta = 0; jeta < njeta; jeta++) {
12275  // positivedirectionRecosignalD:
12276  if (jeta - 41 >= 0) {
12277  // for (int i=0;i<ndepth;i++) {
12278  // depth=6
12279  for (int i = 5; i < 6; i++) {
12280  TH1F *HEpositivedirectionRecosignalD6 = (TH1F *)h2CeffHEpositivedirectionRecosignalD6->Clone("twod1");
12281 
12282  float ccctest = 0; // to avoid empty massive elements
12283  for (int jphi = 0; jphi < nphi; jphi++) {
12284  double ccc1 = recosignalvariancehe[i][jeta][jphi];
12285  if (arecosignalhe[i][jeta][jphi] > 0.) {
12286  HEpositivedirectionRecosignalD6->Fill(jphi, ccc1);
12287  ccctest = 1.; //HEpositivedirectionRecosignalD6->SetBinError(i,0.01);
12288  }
12289  } // for jphi
12290  if (ccctest > 0.) {
12291  //cout<<"1919 kcountHEpositivedirectionRecosignalD6 = "<<kcountHEpositivedirectionRecosignalD6 <<" jeta-41= "<< jeta-41 <<endl;
12292  c3x5->cd(kcountHEpositivedirectionRecosignalD6);
12293  HEpositivedirectionRecosignalD6->SetMarkerStyle(20);
12294  HEpositivedirectionRecosignalD6->SetMarkerSize(0.4);
12295  HEpositivedirectionRecosignalD6->GetYaxis()->SetLabelSize(0.04);
12296  HEpositivedirectionRecosignalD6->SetXTitle("HEpositivedirectionRecosignalD6 \b");
12297  HEpositivedirectionRecosignalD6->SetMarkerColor(2);
12298  HEpositivedirectionRecosignalD6->SetLineColor(0);
12299  gPad->SetGridy();
12300  gPad->SetGridx();
12301  // gPad->SetLogy();
12302  if (kcountHEpositivedirectionRecosignalD6 == 1)
12303  HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 18; depth = 6 \b");
12304  if (kcountHEpositivedirectionRecosignalD6 == 2)
12305  HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 19; depth = 6 \b");
12306  if (kcountHEpositivedirectionRecosignalD6 == 3)
12307  HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 20; depth = 6 \b");
12308  if (kcountHEpositivedirectionRecosignalD6 == 4)
12309  HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 21; depth = 6 \b");
12310  if (kcountHEpositivedirectionRecosignalD6 == 5)
12311  HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 22; depth = 6 \b");
12312  if (kcountHEpositivedirectionRecosignalD6 == 6)
12313  HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 23; depth = 6 \b");
12314  if (kcountHEpositivedirectionRecosignalD6 == 7)
12315  HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 24; depth = 6 \b");
12316  if (kcountHEpositivedirectionRecosignalD6 == 8)
12317  HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 25; depth = 6 \b");
12318  if (kcountHEpositivedirectionRecosignalD6 == 9)
12319  HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 26; depth = 6 \b");
12320  if (kcountHEpositivedirectionRecosignalD6 == 10)
12321  HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 27; depth = 6 \b");
12322  HEpositivedirectionRecosignalD6->Draw("Error");
12323  kcountHEpositivedirectionRecosignalD6++;
12324  if (kcountHEpositivedirectionRecosignalD6 > 10)
12325  break; // 4x6 = 24
12326  } //ccctest>0
12327 
12328  } // for i
12329  } //if(jeta-41 >= 0)
12330  } //for jeta
12332  c3x5->Update();
12333  c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth6HE.png");
12334  c3x5->Clear();
12335  // clean-up
12336  if (h2CeffHEpositivedirectionRecosignalD6)
12337  delete h2CeffHEpositivedirectionRecosignalD6;
12338  //========================================================================================== 20
12339  //======================================================================
12340  //======================================================================1D plot: D vs phi , different eta, depth=7
12341  //cout<<" 1D plot: D vs phi , different eta, depth=7 *****" <<endl;
12342  c3x5->Clear();
12343  c3x5->Divide(3, 5);
12344  c3x5->cd(1);
12345  int kcountHEpositivedirectionRecosignalD7 = 1;
12346  TH1F *h2CeffHEpositivedirectionRecosignalD7 = new TH1F("h2CeffHEpositivedirectionRecosignalD7", "", nphi, 0., 72.);
12347 
12348  for (int jeta = 0; jeta < njeta; jeta++) {
12349  // positivedirectionRecosignalD:
12350  if (jeta - 41 >= 0) {
12351  // for (int i=0;i<ndepth;i++) {
12352  // depth=7
12353  for (int i = 6; i < 7; i++) {
12354  TH1F *HEpositivedirectionRecosignalD7 = (TH1F *)h2CeffHEpositivedirectionRecosignalD7->Clone("twod1");
12355 
12356  float ccctest = 0; // to avoid empty massive elements
12357  for (int jphi = 0; jphi < nphi; jphi++) {
12358  double ccc1 = recosignalvariancehe[i][jeta][jphi];
12359  if (arecosignalhe[i][jeta][jphi] > 0.) {
12360  HEpositivedirectionRecosignalD7->Fill(jphi, ccc1);
12361  ccctest = 1.; //HEpositivedirectionRecosignalD7->SetBinError(i,0.01);
12362  }
12363  } // for jphi
12364  if (ccctest != 0.) {
12365  //cout<<"2020 kcountHEpositivedirectionRecosignalD7 = "<<kcountHEpositivedirectionRecosignalD7 <<" jeta-41= "<< jeta-41 <<endl;
12366  c3x5->cd(kcountHEpositivedirectionRecosignalD7);
12367  HEpositivedirectionRecosignalD7->SetMarkerStyle(20);
12368  HEpositivedirectionRecosignalD7->SetMarkerSize(0.4);
12369  HEpositivedirectionRecosignalD7->GetYaxis()->SetLabelSize(0.04);
12370  HEpositivedirectionRecosignalD7->SetXTitle("HEpositivedirectionRecosignalD7 \b");
12371  HEpositivedirectionRecosignalD7->SetMarkerColor(2);
12372  HEpositivedirectionRecosignalD7->SetLineColor(0);
12373  gPad->SetGridy();
12374  gPad->SetGridx();
12375  // gPad->SetLogy();
12376  if (kcountHEpositivedirectionRecosignalD7 == 1)
12377  HEpositivedirectionRecosignalD7->SetXTitle("D for HE+ jeta = 25; depth = 7 \b");
12378  if (kcountHEpositivedirectionRecosignalD7 == 2)
12379  HEpositivedirectionRecosignalD7->SetXTitle("D for HE+ jeta = 26; depth = 7 \b");
12380  if (kcountHEpositivedirectionRecosignalD7 == 3)
12381  HEpositivedirectionRecosignalD7->SetXTitle("D for HE+ jeta = 27; depth = 7 \b");
12382  HEpositivedirectionRecosignalD7->Draw("Error");
12383  kcountHEpositivedirectionRecosignalD7++;
12384  if (kcountHEpositivedirectionRecosignalD7 > 3)
12385  break; // 4x6 = 24
12386  } //ccctest>0
12387 
12388  } // for i
12389  } //if(jeta-41 >= 0)
12390  } //for jeta
12392  c3x5->Update();
12393  c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth7HE.png");
12394  c3x5->Clear();
12395  // clean-up
12396  if (h2CeffHEpositivedirectionRecosignalD7)
12397  delete h2CeffHEpositivedirectionRecosignalD7;
12398 
12399  //========================================================================================== 22222214
12400  //======================================================================
12401  //======================================================================1D plot: D vs phi , different eta, depth=1
12402  //cout<<" 1D plot: D vs phi , different eta, depth=1 *****" <<endl;
12403  c3x5->Clear();
12405  c3x5->Divide(3, 5);
12406  c3x5->cd(1);
12407  int kcountHEnegativedirectionRecosignalD1 = 1;
12408  TH1F *h2CeffHEnegativedirectionRecosignalD1 = new TH1F("h2CeffHEnegativedirectionRecosignalD1", "", nphi, 0., 72.);
12409 
12410  for (int jeta = 0; jeta < njeta; jeta++) {
12411  // negativedirectionRecosignalD:
12412  if (jeta - 41 < 0) {
12413  // for (int i=0;i<ndepth;i++) {
12414  // depth=1
12415  for (int i = 0; i < 1; i++) {
12416  TH1F *HEnegativedirectionRecosignalD1 = (TH1F *)h2CeffHEnegativedirectionRecosignalD1->Clone("twod1");
12417 
12418  float ccctest = 0; // to avoid empty massive elements
12419  for (int jphi = 0; jphi < nphi; jphi++) {
12420  double ccc1 = recosignalvariancehe[i][jeta][jphi];
12421  if (arecosignalhe[i][jeta][jphi] > 0.) {
12422  HEnegativedirectionRecosignalD1->Fill(jphi, ccc1);
12423  ccctest = 1.; //HEnegativedirectionRecosignalD1->SetBinError(i,0.01);
12424  }
12425  } // for jphi
12426  if (ccctest > 0.) {
12427  //cout<<"1414 kcountHEnegativedirectionRecosignalD1 = "<<kcountHEnegativedirectionRecosignalD1 <<" jeta-41= "<< jeta-41 <<endl;
12428  c3x5->cd(kcountHEnegativedirectionRecosignalD1);
12429  HEnegativedirectionRecosignalD1->SetMarkerStyle(20);
12430  HEnegativedirectionRecosignalD1->SetMarkerSize(0.4);
12431  HEnegativedirectionRecosignalD1->GetYaxis()->SetLabelSize(0.04);
12432  HEnegativedirectionRecosignalD1->SetXTitle("HEnegativedirectionRecosignalD1 \b");
12433  HEnegativedirectionRecosignalD1->SetMarkerColor(2);
12434  HEnegativedirectionRecosignalD1->SetLineColor(0);
12435  gPad->SetGridy();
12436  gPad->SetGridx();
12437  // gPad->SetLogy();
12438  if (kcountHEnegativedirectionRecosignalD1 == 1)
12439  HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-29; depth = 1 \b");
12440  if (kcountHEnegativedirectionRecosignalD1 == 2)
12441  HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-28; depth = 1 \b");
12442  if (kcountHEnegativedirectionRecosignalD1 == 3)
12443  HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-27; depth = 1 \b");
12444  if (kcountHEnegativedirectionRecosignalD1 == 4)
12445  HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-26; depth = 1 \b");
12446  if (kcountHEnegativedirectionRecosignalD1 == 5)
12447  HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-25; depth = 1 \b");
12448  if (kcountHEnegativedirectionRecosignalD1 == 6)
12449  HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-24; depth = 1 \b");
12450  if (kcountHEnegativedirectionRecosignalD1 == 7)
12451  HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-23; depth = 1 \b");
12452  if (kcountHEnegativedirectionRecosignalD1 == 8)
12453  HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-22; depth = 1 \b");
12454  if (kcountHEnegativedirectionRecosignalD1 == 9)
12455  HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-21; depth = 1 \b");
12456  if (kcountHEnegativedirectionRecosignalD1 == 10)
12457  HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-20; depth = 1 \b");
12458  if (kcountHEnegativedirectionRecosignalD1 == 11)
12459  HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-19; depth = 1 \b");
12460  if (kcountHEnegativedirectionRecosignalD1 == 12)
12461  HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-18; depth = 1 \b");
12462  HEnegativedirectionRecosignalD1->Draw("Error");
12463  kcountHEnegativedirectionRecosignalD1++;
12464  if (kcountHEnegativedirectionRecosignalD1 > 12)
12465  break; // 4x6 = 24
12466  } //ccctest>0
12467 
12468  } // for i
12469  } //if(jeta-41 < 0)
12470  } //for jeta
12472  c3x5->Update();
12473  c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth1HE.png");
12474  c3x5->Clear();
12475  // clean-up
12476  if (h2CeffHEnegativedirectionRecosignalD1)
12477  delete h2CeffHEnegativedirectionRecosignalD1;
12478  //========================================================================================== 22222215
12479  //======================================================================
12480  //======================================================================1D plot: D vs phi , different eta, depth=2
12481  //cout<<" 1D plot: D vs phi , different eta, depth=2 *****" <<endl;
12482  c3x5->Clear();
12483  c3x5->Divide(3, 5);
12484  c3x5->cd(1);
12485  int kcountHEnegativedirectionRecosignalD2 = 1;
12486  TH1F *h2CeffHEnegativedirectionRecosignalD2 = new TH1F("h2CeffHEnegativedirectionRecosignalD2", "", nphi, 0., 72.);
12487 
12488  for (int jeta = 0; jeta < njeta; jeta++) {
12489  // negativedirectionRecosignalD:
12490  if (jeta - 41 < 0) {
12491  // for (int i=0;i<ndepth;i++) {
12492  // depth=2
12493  for (int i = 1; i < 2; i++) {
12494  TH1F *HEnegativedirectionRecosignalD2 = (TH1F *)h2CeffHEnegativedirectionRecosignalD2->Clone("twod1");
12495 
12496  float ccctest = 0; // to avoid empty massive elements
12497  for (int jphi = 0; jphi < nphi; jphi++) {
12498  double ccc1 = recosignalvariancehe[i][jeta][jphi];
12499  if (arecosignalhe[i][jeta][jphi] > 0.) {
12500  HEnegativedirectionRecosignalD2->Fill(jphi, ccc1);
12501  ccctest = 1.; //HEnegativedirectionRecosignalD2->SetBinError(i,0.01);
12502  }
12503  } // for jphi
12504  if (ccctest > 0.) {
12505  //cout<<"1515 kcountHEnegativedirectionRecosignalD2 = "<<kcountHEnegativedirectionRecosignalD2 <<" jeta-41= "<< jeta-41 <<endl;
12506  c3x5->cd(kcountHEnegativedirectionRecosignalD2);
12507  HEnegativedirectionRecosignalD2->SetMarkerStyle(20);
12508  HEnegativedirectionRecosignalD2->SetMarkerSize(0.4);
12509  HEnegativedirectionRecosignalD2->GetYaxis()->SetLabelSize(0.04);
12510  HEnegativedirectionRecosignalD2->SetXTitle("HEnegativedirectionRecosignalD2 \b");
12511  HEnegativedirectionRecosignalD2->SetMarkerColor(2);
12512  HEnegativedirectionRecosignalD2->SetLineColor(0);
12513  gPad->SetGridy();
12514  gPad->SetGridx();
12515  // gPad->SetLogy();
12516  if (kcountHEnegativedirectionRecosignalD2 == 1)
12517  HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-29; depth = 2 \b");
12518  if (kcountHEnegativedirectionRecosignalD2 == 2)
12519  HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-28; depth = 2 \b");
12520  if (kcountHEnegativedirectionRecosignalD2 == 3)
12521  HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-27; depth = 2 \b");
12522  if (kcountHEnegativedirectionRecosignalD2 == 4)
12523  HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-26; depth = 2 \b");
12524  if (kcountHEnegativedirectionRecosignalD2 == 5)
12525  HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-25; depth = 2 \b");
12526  if (kcountHEnegativedirectionRecosignalD2 == 6)
12527  HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-24; depth = 2 \b");
12528  if (kcountHEnegativedirectionRecosignalD2 == 7)
12529  HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-23; depth = 2 \b");
12530  if (kcountHEnegativedirectionRecosignalD2 == 8)
12531  HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-22; depth = 2 \b");
12532  if (kcountHEnegativedirectionRecosignalD2 == 9)
12533  HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-21; depth = 2 \b");
12534  if (kcountHEnegativedirectionRecosignalD2 == 10)
12535  HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-20; depth = 2 \b");
12536  if (kcountHEnegativedirectionRecosignalD2 == 11)
12537  HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-19; depth = 2 \b");
12538  if (kcountHEnegativedirectionRecosignalD2 == 12)
12539  HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-18; depth = 2 \b");
12540  if (kcountHEnegativedirectionRecosignalD2 == 13)
12541  HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-17; depth = 2 \b");
12542  HEnegativedirectionRecosignalD2->Draw("Error");
12543  kcountHEnegativedirectionRecosignalD2++;
12544  if (kcountHEnegativedirectionRecosignalD2 > 13)
12545  break; // 4x6 = 24
12546  } //ccctest>0
12547 
12548  } // for i
12549  } //if(jeta-41 < 0)
12550  } //for jeta
12552  c3x5->Update();
12553  c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth2HE.png");
12554  c3x5->Clear();
12555  // clean-up
12556  if (h2CeffHEnegativedirectionRecosignalD2)
12557  delete h2CeffHEnegativedirectionRecosignalD2;
12558  //========================================================================================== 22222216
12559  //======================================================================
12560  //======================================================================1D plot: D vs phi , different eta, depth=3
12561  //cout<<" 1D plot: D vs phi , different eta, depth=3 *****" <<endl;
12562  c3x5->Clear();
12563  c3x5->Divide(3, 5);
12564  c3x5->cd(1);
12565  int kcountHEnegativedirectionRecosignalD3 = 1;
12566  TH1F *h2CeffHEnegativedirectionRecosignalD3 = new TH1F("h2CeffHEnegativedirectionRecosignalD3", "", nphi, 0., 72.);
12567 
12568  for (int jeta = 0; jeta < njeta; jeta++) {
12569  // negativedirectionRecosignalD:
12570  if (jeta - 41 < 0) {
12571  // for (int i=0;i<ndepth;i++) {
12572  // depth=3
12573  for (int i = 2; i < 3; i++) {
12574  TH1F *HEnegativedirectionRecosignalD3 = (TH1F *)h2CeffHEnegativedirectionRecosignalD3->Clone("twod1");
12575 
12576  float ccctest = 0; // to avoid empty massive elements
12577  for (int jphi = 0; jphi < nphi; jphi++) {
12578  double ccc1 = recosignalvariancehe[i][jeta][jphi];
12579  if (arecosignalhe[i][jeta][jphi] > 0.) {
12580  HEnegativedirectionRecosignalD3->Fill(jphi, ccc1);
12581  ccctest = 1.; //HEnegativedirectionRecosignalD3->SetBinError(i,0.01);
12582  }
12583  } // for jphi
12584  if (ccctest > 0.) {
12585  //cout<<"1616 kcountHEnegativedirectionRecosignalD3 = "<<kcountHEnegativedirectionRecosignalD3 <<" jeta-41= "<< jeta-41 <<endl;
12586  c3x5->cd(kcountHEnegativedirectionRecosignalD3);
12587  HEnegativedirectionRecosignalD3->SetMarkerStyle(20);
12588  HEnegativedirectionRecosignalD3->SetMarkerSize(0.4);
12589  HEnegativedirectionRecosignalD3->GetYaxis()->SetLabelSize(0.04);
12590  HEnegativedirectionRecosignalD3->SetXTitle("HEnegativedirectionRecosignalD3 \b");
12591  HEnegativedirectionRecosignalD3->SetMarkerColor(2);
12592  HEnegativedirectionRecosignalD3->SetLineColor(0);
12593  gPad->SetGridy();
12594  gPad->SetGridx();
12595  // gPad->SetLogy();
12596  if (kcountHEnegativedirectionRecosignalD3 == 1)
12597  HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-29; depth = 3 \b");
12598  if (kcountHEnegativedirectionRecosignalD3 == 2)
12599  HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-28; depth = 3 \b");
12600  if (kcountHEnegativedirectionRecosignalD3 == 3)
12601  HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-27; depth = 3 \b");
12602  if (kcountHEnegativedirectionRecosignalD3 == 4)
12603  HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-26; depth = 3 \b");
12604  if (kcountHEnegativedirectionRecosignalD3 == 5)
12605  HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-25; depth = 3 \b");
12606  if (kcountHEnegativedirectionRecosignalD3 == 6)
12607  HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-24; depth = 3 \b");
12608  if (kcountHEnegativedirectionRecosignalD3 == 7)
12609  HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-23; depth = 3 \b");
12610  if (kcountHEnegativedirectionRecosignalD3 == 8)
12611  HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-22; depth = 3 \b");
12612  if (kcountHEnegativedirectionRecosignalD3 == 9)
12613  HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-21; depth = 3 \b");
12614  if (kcountHEnegativedirectionRecosignalD3 == 10)
12615  HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-20; depth = 3 \b");
12616  if (kcountHEnegativedirectionRecosignalD3 == 11)
12617  HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-19; depth = 3 \b");
12618  if (kcountHEnegativedirectionRecosignalD3 == 12)
12619  HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-18; depth = 3 \b");
12620  if (kcountHEnegativedirectionRecosignalD3 == 13)
12621  HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-17; depth = 3 \b");
12622  HEnegativedirectionRecosignalD3->Draw("Error");
12623  kcountHEnegativedirectionRecosignalD3++;
12624  if (kcountHEnegativedirectionRecosignalD3 > 13)
12625  break; // 4x6 = 24
12626  } //ccctest>0
12627 
12628  } // for i
12629  } //if(jeta-41 < 0)
12630  } //for jeta
12632  c3x5->Update();
12633  c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth3HE.png");
12634  c3x5->Clear();
12635  // clean-up
12636  if (h2CeffHEnegativedirectionRecosignalD3)
12637  delete h2CeffHEnegativedirectionRecosignalD3;
12638  //========================================================================================== 22222217
12639  //======================================================================
12640  //======================================================================1D plot: D vs phi , different eta, depth=4
12641  //cout<<" 1D plot: D vs phi , different eta, depth=4 *****" <<endl;
12642  c3x5->Clear();
12643  c3x5->Divide(3, 5);
12644  c3x5->cd(1);
12645  int kcountHEnegativedirectionRecosignalD4 = 1;
12646  TH1F *h2CeffHEnegativedirectionRecosignalD4 = new TH1F("h2CeffHEnegativedirectionRecosignalD4", "", nphi, 0., 72.);
12647 
12648  for (int jeta = 0; jeta < njeta; jeta++) {
12649  // negativedirectionRecosignalD:
12650  if (jeta - 41 < 0) {
12651  // for (int i=0;i<ndepth;i++) {
12652  // depth=4
12653  for (int i = 3; i < 4; i++) {
12654  TH1F *HEnegativedirectionRecosignalD4 = (TH1F *)h2CeffHEnegativedirectionRecosignalD4->Clone("twod1");
12655 
12656  float ccctest = 0; // to avoid empty massive elements
12657  for (int jphi = 0; jphi < nphi; jphi++) {
12658  double ccc1 = recosignalvariancehe[i][jeta][jphi];
12659  if (arecosignalhe[i][jeta][jphi] > 0.) {
12660  HEnegativedirectionRecosignalD4->Fill(jphi, ccc1);
12661  ccctest = 1.; //HEnegativedirectionRecosignalD4->SetBinError(i,0.01);
12662  }
12663  } // for jphi
12664  if (ccctest > 0.) {
12665  //cout<<"1717 kcountHEnegativedirectionRecosignalD4 = "<<kcountHEnegativedirectionRecosignalD4 <<" jeta-41= "<< jeta-41 <<endl;
12666  c3x5->cd(kcountHEnegativedirectionRecosignalD4);
12667  HEnegativedirectionRecosignalD4->SetMarkerStyle(20);
12668  HEnegativedirectionRecosignalD4->SetMarkerSize(0.4);
12669  HEnegativedirectionRecosignalD4->GetYaxis()->SetLabelSize(0.04);
12670  HEnegativedirectionRecosignalD4->SetXTitle("HEnegativedirectionRecosignalD4 \b");
12671  HEnegativedirectionRecosignalD4->SetMarkerColor(2);
12672  HEnegativedirectionRecosignalD4->SetLineColor(0);
12673  gPad->SetGridy();
12674  gPad->SetGridx();
12675  // gPad->SetLogy();
12676  if (kcountHEnegativedirectionRecosignalD4 == 1)
12677  HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-28; depth = 4 \b");
12678  if (kcountHEnegativedirectionRecosignalD4 == 2)
12679  HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-27; depth = 4 \b");
12680  if (kcountHEnegativedirectionRecosignalD4 == 3)
12681  HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-26; depth = 4 \b");
12682  if (kcountHEnegativedirectionRecosignalD4 == 4)
12683  HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-25; depth = 4 \b");
12684  if (kcountHEnegativedirectionRecosignalD4 == 5)
12685  HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-24; depth = 4 \b");
12686  if (kcountHEnegativedirectionRecosignalD4 == 6)
12687  HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-23; depth = 4 \b");
12688  if (kcountHEnegativedirectionRecosignalD4 == 7)
12689  HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-22; depth = 4 \b");
12690  if (kcountHEnegativedirectionRecosignalD4 == 8)
12691  HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-21; depth = 4 \b");
12692  if (kcountHEnegativedirectionRecosignalD4 == 9)
12693  HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-20; depth = 4 \b");
12694  if (kcountHEnegativedirectionRecosignalD4 == 10)
12695  HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-19; depth = 4 \b");
12696  if (kcountHEnegativedirectionRecosignalD4 == 11)
12697  HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-18; depth = 4 \b");
12698  if (kcountHEnegativedirectionRecosignalD4 == 12)
12699  HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-16; depth = 4 \b");
12700  HEnegativedirectionRecosignalD4->Draw("Error");
12701  kcountHEnegativedirectionRecosignalD4++;
12702  if (kcountHEnegativedirectionRecosignalD4 > 12)
12703  break; // 4x6 = 24
12704  } //ccctest>0
12705 
12706  } // for i
12707  } //if(jeta-41 < 0)
12708  } //for jeta
12710  c3x5->Update();
12711  c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth4HE.png");
12712  c3x5->Clear();
12713  // clean-up
12714  if (h2CeffHEnegativedirectionRecosignalD4)
12715  delete h2CeffHEnegativedirectionRecosignalD4;
12716  //========================================================================================== 22222218
12717  //======================================================================
12718  //======================================================================1D plot: D vs phi , different eta, depth=5
12719  //cout<<" 1D plot: D vs phi , different eta, depth=5 *****" <<endl;
12720  c3x5->Clear();
12721  c3x5->Divide(3, 5);
12722  c3x5->cd(1);
12723  int kcountHEnegativedirectionRecosignalD5 = 1;
12724  TH1F *h2CeffHEnegativedirectionRecosignalD5 = new TH1F("h2CeffHEnegativedirectionRecosignalD5", "", nphi, 0., 72.);
12725 
12726  for (int jeta = 0; jeta < njeta; jeta++) {
12727  // negativedirectionRecosignalD:
12728  if (jeta - 41 < 0) {
12729  // for (int i=0;i<ndepth;i++) {
12730  // depth=5
12731  for (int i = 4; i < 5; i++) {
12732  TH1F *HEnegativedirectionRecosignalD5 = (TH1F *)h2CeffHEnegativedirectionRecosignalD5->Clone("twod1");
12733 
12734  float ccctest = 0; // to avoid empty massive elements
12735  for (int jphi = 0; jphi < nphi; jphi++) {
12736  double ccc1 = recosignalvariancehe[i][jeta][jphi];
12737  if (arecosignalhe[i][jeta][jphi] > 0.) {
12738  HEnegativedirectionRecosignalD5->Fill(jphi, ccc1);
12739  ccctest = 1.; //HEnegativedirectionRecosignalD5->SetBinError(i,0.01);
12740  }
12741  } // for jphi
12742  if (ccctest > 0.) {
12743  //cout<<"1818 kcountHEnegativedirectionRecosignalD5 = "<<kcountHEnegativedirectionRecosignalD5 <<" jeta-41= "<< jeta-41 <<endl;
12744  c3x5->cd(kcountHEnegativedirectionRecosignalD5);
12745  HEnegativedirectionRecosignalD5->SetMarkerStyle(20);
12746  HEnegativedirectionRecosignalD5->SetMarkerSize(0.4);
12747  HEnegativedirectionRecosignalD5->GetYaxis()->SetLabelSize(0.04);
12748  HEnegativedirectionRecosignalD5->SetXTitle("HEnegativedirectionRecosignalD5 \b");
12749  HEnegativedirectionRecosignalD5->SetMarkerColor(2);
12750  HEnegativedirectionRecosignalD5->SetLineColor(0);
12751  gPad->SetGridy();
12752  gPad->SetGridx();
12753  // gPad->SetLogy();
12754  if (kcountHEnegativedirectionRecosignalD5 == 1)
12755  HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-28; depth = 5 \b");
12756  if (kcountHEnegativedirectionRecosignalD5 == 2)
12757  HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-27; depth = 5 \b");
12758  if (kcountHEnegativedirectionRecosignalD5 == 3)
12759  HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-26; depth = 5 \b");
12760  if (kcountHEnegativedirectionRecosignalD5 == 4)
12761  HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-25; depth = 5 \b");
12762  if (kcountHEnegativedirectionRecosignalD5 == 5)
12763  HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-24; depth = 5 \b");
12764  if (kcountHEnegativedirectionRecosignalD5 == 6)
12765  HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-23; depth = 5 \b");
12766  if (kcountHEnegativedirectionRecosignalD5 == 7)
12767  HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-22; depth = 5 \b");
12768  if (kcountHEnegativedirectionRecosignalD5 == 8)
12769  HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-21; depth = 5 \b");
12770  if (kcountHEnegativedirectionRecosignalD5 == 9)
12771  HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-20; depth = 5 \b");
12772  if (kcountHEnegativedirectionRecosignalD5 == 10)
12773  HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-19; depth = 5 \b");
12774  if (kcountHEnegativedirectionRecosignalD5 == 11)
12775  HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-18; depth = 5 \b");
12776  HEnegativedirectionRecosignalD5->Draw("Error");
12777  kcountHEnegativedirectionRecosignalD5++;
12778  if (kcountHEnegativedirectionRecosignalD5 > 11)
12779  break; // 4x6 = 24
12780  } //ccctest>0
12781 
12782  } // for i
12783  } //if(jeta-41 < 0)
12784  } //for jeta
12786  c3x5->Update();
12787  c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth5HE.png");
12788  c3x5->Clear();
12789  // clean-up
12790  if (h2CeffHEnegativedirectionRecosignalD5)
12791  delete h2CeffHEnegativedirectionRecosignalD5;
12792  //========================================================================================== 22222219
12793  //======================================================================
12794  //======================================================================1D plot: D vs phi , different eta, depth=6
12795  //cout<<" 1D plot: D vs phi , different eta, depth=6 *****" <<endl;
12796  c3x5->Clear();
12797  c3x5->Divide(3, 5);
12798  c3x5->cd(1);
12799  int kcountHEnegativedirectionRecosignalD6 = 1;
12800  TH1F *h2CeffHEnegativedirectionRecosignalD6 = new TH1F("h2CeffHEnegativedirectionRecosignalD6", "", nphi, 0., 72.);
12801 
12802  for (int jeta = 0; jeta < njeta; jeta++) {
12803  // negativedirectionRecosignalD:
12804  if (jeta - 41 < 0) {
12805  // for (int i=0;i<ndepth;i++) {
12806  // depth=6
12807  for (int i = 5; i < 6; i++) {
12808  TH1F *HEnegativedirectionRecosignalD6 = (TH1F *)h2CeffHEnegativedirectionRecosignalD6->Clone("twod1");
12809 
12810  float ccctest = 0; // to avoid empty massive elements
12811  for (int jphi = 0; jphi < nphi; jphi++) {
12812  double ccc1 = recosignalvariancehe[i][jeta][jphi];
12813  if (arecosignalhe[i][jeta][jphi] > 0.) {
12814  HEnegativedirectionRecosignalD6->Fill(jphi, ccc1);
12815  ccctest = 1.; //HEnegativedirectionRecosignalD6->SetBinError(i,0.01);
12816  }
12817  } // for jphi
12818  if (ccctest > 0.) {
12819  //cout<<"1919 kcountHEnegativedirectionRecosignalD6 = "<<kcountHEnegativedirectionRecosignalD6 <<" jeta-41= "<< jeta-41 <<endl;
12820  c3x5->cd(kcountHEnegativedirectionRecosignalD6);
12821  HEnegativedirectionRecosignalD6->SetMarkerStyle(20);
12822  HEnegativedirectionRecosignalD6->SetMarkerSize(0.4);
12823  HEnegativedirectionRecosignalD6->GetYaxis()->SetLabelSize(0.04);
12824  HEnegativedirectionRecosignalD6->SetXTitle("HEnegativedirectionRecosignalD6 \b");
12825  HEnegativedirectionRecosignalD6->SetMarkerColor(2);
12826  HEnegativedirectionRecosignalD6->SetLineColor(0);
12827  gPad->SetGridy();
12828  gPad->SetGridx();
12829  // gPad->SetLogy();
12830  if (kcountHEnegativedirectionRecosignalD6 == 1)
12831  HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-28; depth = 6 \b");
12832  if (kcountHEnegativedirectionRecosignalD6 == 2)
12833  HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-27; depth = 6 \b");
12834  if (kcountHEnegativedirectionRecosignalD6 == 3)
12835  HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-26; depth = 6 \b");
12836  if (kcountHEnegativedirectionRecosignalD6 == 4)
12837  HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-25; depth = 6 \b");
12838  if (kcountHEnegativedirectionRecosignalD6 == 5)
12839  HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-24; depth = 6 \b");
12840  if (kcountHEnegativedirectionRecosignalD6 == 6)
12841  HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-23; depth = 6 \b");
12842  if (kcountHEnegativedirectionRecosignalD6 == 7)
12843  HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-22; depth = 6 \b");
12844  if (kcountHEnegativedirectionRecosignalD6 == 8)
12845  HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-21; depth = 6 \b");
12846  if (kcountHEnegativedirectionRecosignalD6 == 9)
12847  HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-20; depth = 6 \b");
12848  if (kcountHEnegativedirectionRecosignalD6 == 10)
12849  HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-19; depth = 6 \b");
12850  HEnegativedirectionRecosignalD6->Draw("Error");
12851  kcountHEnegativedirectionRecosignalD6++;
12852  if (kcountHEnegativedirectionRecosignalD6 > 10)
12853  break; // 4x6 = 24
12854  } //ccctest>0
12855 
12856  } // for i
12857  } //if(jeta-41 < 0)
12858  } //for jeta
12860  c3x5->Update();
12861  c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth6HE.png");
12862  c3x5->Clear();
12863  // clean-up
12864  if (h2CeffHEnegativedirectionRecosignalD6)
12865  delete h2CeffHEnegativedirectionRecosignalD6;
12866  //========================================================================================== 22222220
12867  //======================================================================
12868  //======================================================================1D plot: D vs phi , different eta, depth=7
12869  //cout<<" 1D plot: D vs phi , different eta, depth=7 *****" <<endl;
12870  c3x5->Clear();
12871  c3x5->Divide(3, 5);
12872  c3x5->cd(1);
12873  int kcountHEnegativedirectionRecosignalD7 = 1;
12874  TH1F *h2CeffHEnegativedirectionRecosignalD7 = new TH1F("h2CeffHEnegativedirectionRecosignalD7", "", nphi, 0., 72.);
12875 
12876  for (int jeta = 0; jeta < njeta; jeta++) {
12877  // negativedirectionRecosignalD:
12878  if (jeta - 41 < 0) {
12879  // for (int i=0;i<ndepth;i++) {
12880  // depth=7
12881  for (int i = 6; i < 7; i++) {
12882  TH1F *HEnegativedirectionRecosignalD7 = (TH1F *)h2CeffHEnegativedirectionRecosignalD7->Clone("twod1");
12883 
12884  float ccctest = 0; // to avoid empty massive elements
12885  for (int jphi = 0; jphi < nphi; jphi++) {
12886  double ccc1 = recosignalvariancehe[i][jeta][jphi];
12887  if (arecosignalhe[i][jeta][jphi] > 0.) {
12888  HEnegativedirectionRecosignalD7->Fill(jphi, ccc1);
12889  ccctest = 1.; //HEnegativedirectionRecosignalD7->SetBinError(i,0.01);
12890  }
12891  } // for jphi
12892  if (ccctest != 0.) {
12893  //cout<<"2020 kcountHEnegativedirectionRecosignalD7 = "<<kcountHEnegativedirectionRecosignalD7 <<" jeta-41= "<< jeta-41 <<endl;
12894  c3x5->cd(kcountHEnegativedirectionRecosignalD7);
12895  HEnegativedirectionRecosignalD7->SetMarkerStyle(20);
12896  HEnegativedirectionRecosignalD7->SetMarkerSize(0.4);
12897  HEnegativedirectionRecosignalD7->GetYaxis()->SetLabelSize(0.04);
12898  HEnegativedirectionRecosignalD7->SetXTitle("HEnegativedirectionRecosignalD7 \b");
12899  HEnegativedirectionRecosignalD7->SetMarkerColor(2);
12900  HEnegativedirectionRecosignalD7->SetLineColor(0);
12901  gPad->SetGridy();
12902  gPad->SetGridx();
12903  // gPad->SetLogy();
12904  if (kcountHEnegativedirectionRecosignalD7 == 1)
12905  HEnegativedirectionRecosignalD7->SetXTitle("D for HE- jeta =-28; depth = 7 \b");
12906  if (kcountHEnegativedirectionRecosignalD7 == 2)
12907  HEnegativedirectionRecosignalD7->SetXTitle("D for HE- jeta =-27; depth = 7 \b");
12908  if (kcountHEnegativedirectionRecosignalD7 == 3)
12909  HEnegativedirectionRecosignalD7->SetXTitle("D for HE- jeta =-26; depth = 7 \b");
12910  HEnegativedirectionRecosignalD7->Draw("Error");
12911  kcountHEnegativedirectionRecosignalD7++;
12912  if (kcountHEnegativedirectionRecosignalD7 > 3)
12913  break; // 4x6 = 24
12914  } //ccctest>0
12915 
12916  } // for i
12917  } //if(jeta-41 < 0)
12918  } //for jeta
12920  c3x5->Update();
12921  c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth7HE.png");
12922  c3x5->Clear();
12923  // clean-up
12924  if (h2CeffHEnegativedirectionRecosignalD7)
12925  delete h2CeffHEnegativedirectionRecosignalD7;
12926  //===================================================================== END of Recosignal HE for phi-symmetry
12927  //===================================================================== END of Recosignal HE for phi-symmetry
12928  //===================================================================== END of Recosignal HE for phi-symmetry
12932  // int k_max[5]={0,4,7,4,4}; // maximum depth for each subdet
12933  //ndepth = k_max[5];
12934  ndepth = 2;
12935  double arecosignalHF[ndepth][njeta][njphi];
12936  double recosignalvarianceHF[ndepth][njeta][njphi];
12937  //cout<<"111RRRRRRRRRRRRRRRRRRRRRRRRR Recosignal HF" <<endl;
12938  // RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR: Recosignal HF
12939  TH2F *recSignalEnergy1HF1 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy1_HF1");
12940  TH2F *recSignalEnergy0HF1 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HF1");
12941  TH2F *recSignalEnergyHF1 = (TH2F *)recSignalEnergy1HF1->Clone("recSignalEnergyHF1");
12942  recSignalEnergyHF1->Divide(recSignalEnergy1HF1, recSignalEnergy0HF1, 1, 1, "B");
12943  TH2F *recSignalEnergy1HF2 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy1_HF2");
12944  TH2F *recSignalEnergy0HF2 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HF2");
12945  TH2F *recSignalEnergyHF2 = (TH2F *)recSignalEnergy1HF2->Clone("recSignalEnergyHF2");
12946  recSignalEnergyHF2->Divide(recSignalEnergy1HF2, recSignalEnergy0HF2, 1, 1, "B");
12947  // cout<<"222RRRRRRRRRRRRRRRRRRRRRRRRR Recosignal HF" <<endl;
12948  //====================================================================== PHI normalization & put R into massive arecosignalHF
12949  for (int jeta = 0; jeta < njeta; jeta++) {
12950  //preparation for PHI normalization:
12951  double sumrecosignalHF0 = 0;
12952  int nsumrecosignalHF0 = 0;
12953  double sumrecosignalHF1 = 0;
12954  int nsumrecosignalHF1 = 0;
12955  for (int jphi = 0; jphi < njphi; jphi++) {
12956  arecosignalHF[0][jeta][jphi] = recSignalEnergyHF1->GetBinContent(jeta + 1, jphi + 1);
12957  arecosignalHF[1][jeta][jphi] = recSignalEnergyHF2->GetBinContent(jeta + 1, jphi + 1);
12958  if (arecosignalHF[0][jeta][jphi] > 0.) {
12959  sumrecosignalHF0 += arecosignalHF[0][jeta][jphi];
12960  ++nsumrecosignalHF0;
12961  }
12962  if (arecosignalHF[1][jeta][jphi] > 0.) {
12963  sumrecosignalHF1 += arecosignalHF[1][jeta][jphi];
12964  ++nsumrecosignalHF1;
12965  }
12966  } // phi
12967  // PHI normalization:
12968  for (int jphi = 0; jphi < njphi; jphi++) {
12969  if (arecosignalHF[0][jeta][jphi] > 0.)
12970  arecosignalHF[0][jeta][jphi] /= (sumrecosignalHF0 / nsumrecosignalHF0);
12971  if (arecosignalHF[1][jeta][jphi] > 0.)
12972  arecosignalHF[1][jeta][jphi] /= (sumrecosignalHF1 / nsumrecosignalHF1);
12973  } // phi
12974  } //eta
12975  //------------------------ 2D-eta/phi-plot: R, averaged over depthfs
12976  //======================================================================
12977  //======================================================================
12978  // cout<<" R2D-eta/phi-plot: R, averaged over depthfs *****" <<endl;
12979  c2x1->Clear();
12981  c2x1->Divide(2, 1);
12982  c2x1->cd(1);
12983  TH2F *GefzRrecosignalHF42D = new TH2F("GefzRrecosignalHF42D", "", neta, -41., 41., nphi, 0., 72.);
12984  TH2F *GefzRrecosignalHF42D0 = new TH2F("GefzRrecosignalHF42D0", "", neta, -41., 41., nphi, 0., 72.);
12985  TH2F *GefzRrecosignalHF42DF = (TH2F *)GefzRrecosignalHF42D0->Clone("GefzRrecosignalHF42DF");
12986  for (int i = 0; i < ndepth; i++) {
12987  for (int jeta = 0; jeta < neta; jeta++) {
12988  for (int jphi = 0; jphi < nphi; jphi++) {
12989  double ccc1 = arecosignalHF[i][jeta][jphi];
12990  int k2plot = jeta - 41;
12991  int kkk = k2plot; //if(k2plot >0 ) kkk=k2plot+1; //-41 +41 !=0
12992  if (ccc1 != 0.) {
12993  GefzRrecosignalHF42D->Fill(kkk, jphi, ccc1);
12994  GefzRrecosignalHF42D0->Fill(kkk, jphi, 1.);
12995  }
12996  }
12997  }
12998  }
12999  GefzRrecosignalHF42DF->Divide(GefzRrecosignalHF42D, GefzRrecosignalHF42D0, 1, 1, "B"); // average A
13000  gPad->SetGridy();
13001  gPad->SetGridx(); // gPad->SetLogz();
13002  GefzRrecosignalHF42DF->SetXTitle("<R>_depth #eta \b");
13003  GefzRrecosignalHF42DF->SetYTitle(" #phi \b");
13004  GefzRrecosignalHF42DF->Draw("COLZ");
13005 
13006  c2x1->cd(2);
13007  TH1F *energyhitSignal_HF = (TH1F *)dir->FindObjectAny("h_energyhitSignal_HF");
13008  energyhitSignal_HF->SetMarkerStyle(20);
13009  energyhitSignal_HF->SetMarkerSize(0.4);
13010  energyhitSignal_HF->GetYaxis()->SetLabelSize(0.04);
13011  energyhitSignal_HF->SetXTitle("energyhitSignal_HF \b");
13012  energyhitSignal_HF->SetMarkerColor(2);
13013  energyhitSignal_HF->SetLineColor(0);
13014  gPad->SetGridy();
13015  gPad->SetGridx();
13016  energyhitSignal_HF->Draw("Error");
13017 
13019  c2x1->Update();
13020  c2x1->Print("RrecosignalGeneralD2PhiSymmetryHF.png");
13021  c2x1->Clear();
13022  // clean-up
13023  if (GefzRrecosignalHF42D)
13024  delete GefzRrecosignalHF42D;
13025  if (GefzRrecosignalHF42D0)
13026  delete GefzRrecosignalHF42D0;
13027  if (GefzRrecosignalHF42DF)
13028  delete GefzRrecosignalHF42DF;
13029  //====================================================================== 1D plot: R vs phi , averaged over depthfs & eta
13030  //======================================================================
13031  //cout<<" 1D plot: R vs phi , averaged over depthfs & eta *****" <<endl;
13032  c1x1->Clear();
13034  c1x1->Divide(1, 1);
13035  c1x1->cd(1);
13036  TH1F *GefzRrecosignalHF41D = new TH1F("GefzRrecosignalHF41D", "", nphi, 0., 72.);
13037  TH1F *GefzRrecosignalHF41D0 = new TH1F("GefzRrecosignalHF41D0", "", nphi, 0., 72.);
13038  TH1F *GefzRrecosignalHF41DF = (TH1F *)GefzRrecosignalHF41D0->Clone("GefzRrecosignalHF41DF");
13039  for (int jphi = 0; jphi < nphi; jphi++) {
13040  for (int jeta = 0; jeta < neta; jeta++) {
13041  for (int i = 0; i < ndepth; i++) {
13042  double ccc1 = arecosignalHF[i][jeta][jphi];
13043  if (ccc1 != 0.) {
13044  GefzRrecosignalHF41D->Fill(jphi, ccc1);
13045  GefzRrecosignalHF41D0->Fill(jphi, 1.);
13046  }
13047  }
13048  }
13049  }
13050  GefzRrecosignalHF41DF->Divide(
13051  GefzRrecosignalHF41D, GefzRrecosignalHF41D0, 1, 1, "B"); // R averaged over depthfs & eta
13052  GefzRrecosignalHF41D0->Sumw2();
13053  // for (int jphi=1;jphi<73;jphi++) {GefzRrecosignalHF41DF->SetBinError(jphi,0.01);}
13054  gPad->SetGridy();
13055  gPad->SetGridx(); // gPad->SetLogz();
13056  GefzRrecosignalHF41DF->SetMarkerStyle(20);
13057  GefzRrecosignalHF41DF->SetMarkerSize(1.4);
13058  GefzRrecosignalHF41DF->GetZaxis()->SetLabelSize(0.08);
13059  GefzRrecosignalHF41DF->SetXTitle("#phi \b");
13060  GefzRrecosignalHF41DF->SetYTitle(" <R> \b");
13061  GefzRrecosignalHF41DF->SetZTitle("<R>_PHI - AllDepthfs \b");
13062  GefzRrecosignalHF41DF->SetMarkerColor(4);
13063  GefzRrecosignalHF41DF->SetLineColor(
13064  4); // GefzRrecosignalHF41DF->SetMinimum(0.8); // GefzRrecosignalHF41DF->SetMaximum(1.000);
13065  GefzRrecosignalHF41DF->Draw("Error");
13067  c1x1->Update();
13068  c1x1->Print("RrecosignalGeneralD1PhiSymmetryHF.png");
13069  c1x1->Clear();
13070  // clean-up
13071  if (GefzRrecosignalHF41D)
13072  delete GefzRrecosignalHF41D;
13073  if (GefzRrecosignalHF41D0)
13074  delete GefzRrecosignalHF41D0;
13075  if (GefzRrecosignalHF41DF)
13076  delete GefzRrecosignalHF41DF;
13077  //========================================================================================== 4
13078  //======================================================================
13079  //======================================================================1D plot: R vs phi , different eta, depth=1
13080  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
13081  c3x5->Clear();
13083  c3x5->Divide(3, 5);
13084  c3x5->cd(1);
13085  int kcountHFpositivedirectionRecosignal1 = 1;
13086  TH1F *h2CeffHFpositivedirectionRecosignal1 = new TH1F("h2CeffHFpositivedirectionRecosignal1", "", nphi, 0., 72.);
13087  for (int jeta = 0; jeta < njeta; jeta++) {
13088  // positivedirectionRecosignal:
13089  if (jeta - 41 >= 0) {
13090  // for (int i=0;i<ndepth;i++) {
13091  // depth=1
13092  for (int i = 0; i < 1; i++) {
13093  TH1F *HFpositivedirectionRecosignal1 = (TH1F *)h2CeffHFpositivedirectionRecosignal1->Clone("twod1");
13094  float ccctest = 0; // to avoid empty massive elements
13095  for (int jphi = 0; jphi < nphi; jphi++) {
13096  double ccc1 = arecosignalHF[i][jeta][jphi];
13097  if (ccc1 != 0.) {
13098  HFpositivedirectionRecosignal1->Fill(jphi, ccc1);
13099  ccctest = 1.; //HFpositivedirectionRecosignal1->SetBinError(i,0.01);
13100  }
13101  } // for jphi
13102  if (ccctest > 0.) {
13103  // cout<<"444 kcountHFpositivedirectionRecosignal1 = "<<kcountHFpositivedirectionRecosignal1 <<" jeta-41= "<< jeta-41 <<endl;
13104  c3x5->cd(kcountHFpositivedirectionRecosignal1);
13105  HFpositivedirectionRecosignal1->SetMarkerStyle(20);
13106  HFpositivedirectionRecosignal1->SetMarkerSize(0.4);
13107  HFpositivedirectionRecosignal1->GetYaxis()->SetLabelSize(0.04);
13108  HFpositivedirectionRecosignal1->SetXTitle("HFpositivedirectionRecosignal1 \b");
13109  HFpositivedirectionRecosignal1->SetMarkerColor(2);
13110  HFpositivedirectionRecosignal1->SetLineColor(0);
13111  gPad->SetGridy();
13112  gPad->SetGridx();
13113  // gPad->SetLogy();
13114  if (kcountHFpositivedirectionRecosignal1 == 1)
13115  HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 28; depth = 1 \b");
13116  if (kcountHFpositivedirectionRecosignal1 == 2)
13117  HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 29; depth = 1 \b");
13118  if (kcountHFpositivedirectionRecosignal1 == 3)
13119  HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 30; depth = 1 \b");
13120  if (kcountHFpositivedirectionRecosignal1 == 4)
13121  HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 31; depth = 1 \b");
13122  if (kcountHFpositivedirectionRecosignal1 == 5)
13123  HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 32; depth = 1 \b");
13124  if (kcountHFpositivedirectionRecosignal1 == 6)
13125  HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 33; depth = 1 \b");
13126  if (kcountHFpositivedirectionRecosignal1 == 7)
13127  HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 34; depth = 1 \b");
13128  if (kcountHFpositivedirectionRecosignal1 == 8)
13129  HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 35; depth = 1 \b");
13130  if (kcountHFpositivedirectionRecosignal1 == 9)
13131  HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 36; depth = 1 \b");
13132  if (kcountHFpositivedirectionRecosignal1 == 10)
13133  HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 37; depth = 1 \b");
13134  if (kcountHFpositivedirectionRecosignal1 == 11)
13135  HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 38; depth = 1 \b");
13136  if (kcountHFpositivedirectionRecosignal1 == 12)
13137  HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 39; depth = 1 \b");
13138  if (kcountHFpositivedirectionRecosignal1 == 13)
13139  HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 40; depth = 1 \b");
13140  HFpositivedirectionRecosignal1->Draw("Error");
13141  kcountHFpositivedirectionRecosignal1++;
13142  if (kcountHFpositivedirectionRecosignal1 > 13)
13143  break; //
13144  } //ccctest>0
13145 
13146  } // for i
13147  } //if(jeta-41 >= 0)
13148  } //for jeta
13150  c3x5->Update();
13151  c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth1HF.png");
13152  c3x5->Clear();
13153  // clean-up
13154  if (h2CeffHFpositivedirectionRecosignal1)
13155  delete h2CeffHFpositivedirectionRecosignal1;
13156 
13157  //========================================================================================== 5
13158  //======================================================================
13159  //======================================================================1D plot: R vs phi , different eta, depth=2
13160  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
13161  c3x5->Clear();
13163  c3x5->Divide(3, 5);
13164  c3x5->cd(1);
13165  int kcountHFpositivedirectionRecosignal2 = 1;
13166  TH1F *h2CeffHFpositivedirectionRecosignal2 = new TH1F("h2CeffHFpositivedirectionRecosignal2", "", nphi, 0., 72.);
13167  for (int jeta = 0; jeta < njeta; jeta++) {
13168  // positivedirectionRecosignal:
13169  if (jeta - 41 >= 0) {
13170  // for (int i=0;i<ndepth;i++) {
13171  // depth=2
13172  for (int i = 1; i < 2; i++) {
13173  TH1F *HFpositivedirectionRecosignal2 = (TH1F *)h2CeffHFpositivedirectionRecosignal2->Clone("twod1");
13174  float ccctest = 0; // to avoid empty massive elements
13175  for (int jphi = 0; jphi < nphi; jphi++) {
13176  double ccc1 = arecosignalHF[i][jeta][jphi];
13177  if (ccc1 != 0.) {
13178  HFpositivedirectionRecosignal2->Fill(jphi, ccc1);
13179  ccctest = 1.; //HFpositivedirectionRecosignal2->SetBinError(i,0.01);
13180  }
13181  } // for jphi
13182  if (ccctest > 0.) {
13183  //cout<<"555 kcountHFpositivedirectionRecosignal2 = "<<kcountHFpositivedirectionRecosignal2 <<" jeta-41= "<< jeta-41 <<endl;
13184  c3x5->cd(kcountHFpositivedirectionRecosignal2);
13185  HFpositivedirectionRecosignal2->SetMarkerStyle(20);
13186  HFpositivedirectionRecosignal2->SetMarkerSize(0.4);
13187  HFpositivedirectionRecosignal2->GetYaxis()->SetLabelSize(0.04);
13188  HFpositivedirectionRecosignal2->SetXTitle("HFpositivedirectionRecosignal2 \b");
13189  HFpositivedirectionRecosignal2->SetMarkerColor(2);
13190  HFpositivedirectionRecosignal2->SetLineColor(0);
13191  gPad->SetGridy();
13192  gPad->SetGridx();
13193  // gPad->SetLogy();
13194  if (kcountHFpositivedirectionRecosignal2 == 1)
13195  HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 28; depth = 2 \b");
13196  if (kcountHFpositivedirectionRecosignal2 == 2)
13197  HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 29; depth = 2 \b");
13198  if (kcountHFpositivedirectionRecosignal2 == 3)
13199  HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 30; depth = 2 \b");
13200  if (kcountHFpositivedirectionRecosignal2 == 4)
13201  HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 31; depth = 2 \b");
13202  if (kcountHFpositivedirectionRecosignal2 == 5)
13203  HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 32; depth = 2 \b");
13204  if (kcountHFpositivedirectionRecosignal2 == 6)
13205  HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 33; depth = 2 \b");
13206  if (kcountHFpositivedirectionRecosignal2 == 7)
13207  HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 34; depth = 2 \b");
13208  if (kcountHFpositivedirectionRecosignal2 == 8)
13209  HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 35; depth = 2 \b");
13210  if (kcountHFpositivedirectionRecosignal2 == 9)
13211  HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 36; depth = 2 \b");
13212  if (kcountHFpositivedirectionRecosignal2 == 10)
13213  HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 37; depth = 2 \b");
13214  if (kcountHFpositivedirectionRecosignal2 == 11)
13215  HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 38; depth = 2 \b");
13216  if (kcountHFpositivedirectionRecosignal2 == 12)
13217  HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 39; depth = 2 \b");
13218  if (kcountHFpositivedirectionRecosignal2 == 13)
13219  HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 40; depth = 2 \b");
13220  HFpositivedirectionRecosignal2->Draw("Error");
13221  kcountHFpositivedirectionRecosignal2++;
13222  if (kcountHFpositivedirectionRecosignal2 > 13)
13223  break; // 4x6 = 24
13224  } //ccctest>0
13225 
13226  } // for i
13227  } //if(jeta-41 >= 0)
13228  } //for jeta
13230  c3x5->Update();
13231  c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth2HF.png");
13232  c3x5->Clear();
13233  // clean-up
13234  if (h2CeffHFpositivedirectionRecosignal2)
13235  delete h2CeffHFpositivedirectionRecosignal2;
13236 
13237  //========================================================================================== 1111114
13238  //======================================================================
13239  //======================================================================1D plot: R vs phi , different eta, depth=1
13240  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
13241  c3x5->Clear();
13243  c3x5->Divide(3, 5);
13244  c3x5->cd(1);
13245  int kcountHFnegativedirectionRecosignal1 = 1;
13246  TH1F *h2CeffHFnegativedirectionRecosignal1 = new TH1F("h2CeffHFnegativedirectionRecosignal1", "", nphi, 0., 72.);
13247  for (int jeta = 0; jeta < njeta; jeta++) {
13248  // negativedirectionRecosignal:
13249  if (jeta - 41 < 0) {
13250  // for (int i=0;i<ndepth;i++) {
13251  // depth=1
13252  for (int i = 0; i < 1; i++) {
13253  TH1F *HFnegativedirectionRecosignal1 = (TH1F *)h2CeffHFnegativedirectionRecosignal1->Clone("twod1");
13254  float ccctest = 0; // to avoid empty massive elements
13255  for (int jphi = 0; jphi < nphi; jphi++) {
13256  double ccc1 = arecosignalHF[i][jeta][jphi];
13257  if (ccc1 != 0.) {
13258  HFnegativedirectionRecosignal1->Fill(jphi, ccc1);
13259  ccctest = 1.; //HFnegativedirectionRecosignal1->SetBinError(i,0.01);
13260  }
13261  } // for jphi
13262  if (ccctest > 0.) {
13263  // cout<<"444 kcountHFnegativedirectionRecosignal1 = "<<kcountHFnegativedirectionRecosignal1 <<" jeta-41= "<< jeta-41 <<endl;
13264  c3x5->cd(kcountHFnegativedirectionRecosignal1);
13265  HFnegativedirectionRecosignal1->SetMarkerStyle(20);
13266  HFnegativedirectionRecosignal1->SetMarkerSize(0.4);
13267  HFnegativedirectionRecosignal1->GetYaxis()->SetLabelSize(0.04);
13268  HFnegativedirectionRecosignal1->SetXTitle("HFnegativedirectionRecosignal1 \b");
13269  HFnegativedirectionRecosignal1->SetMarkerColor(2);
13270  HFnegativedirectionRecosignal1->SetLineColor(0);
13271  gPad->SetGridy();
13272  gPad->SetGridx();
13273  // gPad->SetLogy();
13274  if (kcountHFnegativedirectionRecosignal1 == 1)
13275  HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-41; depth = 1 \b");
13276  if (kcountHFnegativedirectionRecosignal1 == 2)
13277  HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-40; depth = 1 \b");
13278  if (kcountHFnegativedirectionRecosignal1 == 3)
13279  HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-39; depth = 1 \b");
13280  if (kcountHFnegativedirectionRecosignal1 == 4)
13281  HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-38; depth = 1 \b");
13282  if (kcountHFnegativedirectionRecosignal1 == 5)
13283  HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-37; depth = 1 \b");
13284  if (kcountHFnegativedirectionRecosignal1 == 6)
13285  HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-36; depth = 1 \b");
13286  if (kcountHFnegativedirectionRecosignal1 == 7)
13287  HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-35; depth = 1 \b");
13288  if (kcountHFnegativedirectionRecosignal1 == 8)
13289  HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-34; depth = 1 \b");
13290  if (kcountHFnegativedirectionRecosignal1 == 9)
13291  HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-33; depth = 1 \b");
13292  if (kcountHFnegativedirectionRecosignal1 == 10)
13293  HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-32; depth = 1 \b");
13294  if (kcountHFnegativedirectionRecosignal1 == 11)
13295  HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-31; depth = 1 \b");
13296  if (kcountHFnegativedirectionRecosignal1 == 12)
13297  HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-30; depth = 1 \b");
13298  if (kcountHFnegativedirectionRecosignal1 == 13)
13299  HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-29; depth = 1 \b");
13300  HFnegativedirectionRecosignal1->Draw("Error");
13301  kcountHFnegativedirectionRecosignal1++;
13302  if (kcountHFnegativedirectionRecosignal1 > 13)
13303  break; //
13304  } //ccctest>0
13305 
13306  } // for i
13307  } //if(jeta-41< 0)
13308  } //for jeta
13310  c3x5->Update();
13311  c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth1HF.png");
13312  c3x5->Clear();
13313  // clean-up
13314  if (h2CeffHFnegativedirectionRecosignal1)
13315  delete h2CeffHFnegativedirectionRecosignal1;
13316 
13317  //========================================================================================== 1111115
13318  //======================================================================
13319  //======================================================================1D plot: R vs phi , different eta, depth=2
13320  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
13321  c3x5->Clear();
13323  c3x5->Divide(3, 5);
13324  c3x5->cd(1);
13325  int kcountHFnegativedirectionRecosignal2 = 1;
13326  TH1F *h2CeffHFnegativedirectionRecosignal2 = new TH1F("h2CeffHFnegativedirectionRecosignal2", "", nphi, 0., 72.);
13327  for (int jeta = 0; jeta < njeta; jeta++) {
13328  // negativedirectionRecosignal:
13329  if (jeta - 41 < 0) {
13330  // for (int i=0;i<ndepth;i++) {
13331  // depth=2
13332  for (int i = 1; i < 2; i++) {
13333  TH1F *HFnegativedirectionRecosignal2 = (TH1F *)h2CeffHFnegativedirectionRecosignal2->Clone("twod1");
13334  float ccctest = 0; // to avoid empty massive elements
13335  for (int jphi = 0; jphi < nphi; jphi++) {
13336  double ccc1 = arecosignalHF[i][jeta][jphi];
13337  if (ccc1 != 0.) {
13338  HFnegativedirectionRecosignal2->Fill(jphi, ccc1);
13339  ccctest = 1.; //HFnegativedirectionRecosignal2->SetBinError(i,0.01);
13340  }
13341  } // for jphi
13342  if (ccctest > 0.) {
13343  //cout<<"555 kcountHFnegativedirectionRecosignal2 = "<<kcountHFnegativedirectionRecosignal2 <<" jeta-41= "<< jeta-41 <<endl;
13344  c3x5->cd(kcountHFnegativedirectionRecosignal2);
13345  HFnegativedirectionRecosignal2->SetMarkerStyle(20);
13346  HFnegativedirectionRecosignal2->SetMarkerSize(0.4);
13347  HFnegativedirectionRecosignal2->GetYaxis()->SetLabelSize(0.04);
13348  HFnegativedirectionRecosignal2->SetXTitle("HFnegativedirectionRecosignal2 \b");
13349  HFnegativedirectionRecosignal2->SetMarkerColor(2);
13350  HFnegativedirectionRecosignal2->SetLineColor(0);
13351  gPad->SetGridy();
13352  gPad->SetGridx();
13353  // gPad->SetLogy();
13354  if (kcountHFnegativedirectionRecosignal2 == 1)
13355  HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-41; depth = 2 \b");
13356  if (kcountHFnegativedirectionRecosignal2 == 2)
13357  HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-40; depth = 2 \b");
13358  if (kcountHFnegativedirectionRecosignal2 == 3)
13359  HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-39; depth = 2 \b");
13360  if (kcountHFnegativedirectionRecosignal2 == 4)
13361  HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-38; depth = 2 \b");
13362  if (kcountHFnegativedirectionRecosignal2 == 5)
13363  HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-37; depth = 2 \b");
13364  if (kcountHFnegativedirectionRecosignal2 == 6)
13365  HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-36; depth = 2 \b");
13366  if (kcountHFnegativedirectionRecosignal2 == 7)
13367  HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-35; depth = 2 \b");
13368  if (kcountHFnegativedirectionRecosignal2 == 8)
13369  HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-34; depth = 2 \b");
13370  if (kcountHFnegativedirectionRecosignal2 == 9)
13371  HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-33; depth = 2 \b");
13372  if (kcountHFnegativedirectionRecosignal2 == 10)
13373  HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-32; depth = 2 \b");
13374  if (kcountHFnegativedirectionRecosignal2 == 11)
13375  HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-31; depth = 2 \b");
13376  if (kcountHFnegativedirectionRecosignal2 == 12)
13377  HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-30; depth = 2 \b");
13378  if (kcountHFnegativedirectionRecosignal2 == 13)
13379  HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-20; depth = 2 \b");
13380  HFnegativedirectionRecosignal2->Draw("Error");
13381  kcountHFnegativedirectionRecosignal2++;
13382  if (kcountHFnegativedirectionRecosignal2 > 13)
13383  break; // 4x6 = 24
13384  } //ccctest>0
13385 
13386  } // for i
13387  } //if(jeta-41< 0)
13388  } //for jeta
13390  c3x5->Update();
13391  c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth2HF.png");
13392  c3x5->Clear();
13393  // clean-up
13394  if (h2CeffHFnegativedirectionRecosignal2)
13395  delete h2CeffHFnegativedirectionRecosignal2;
13396 
13397  //======================================================================================================================
13398  //======================================================================================================================
13399  //======================================================================================================================
13400  // DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD:
13401 
13402  //cout<<" Start Vaiance: preparation *****" <<endl;
13403  TH2F *recosignalVariance1HF1 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy2_HF1");
13404  TH2F *recosignalVariance0HF1 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HF1");
13405  TH2F *recosignalVarianceHF1 = (TH2F *)recosignalVariance1HF1->Clone("recosignalVarianceHF1");
13406  recosignalVarianceHF1->Divide(recosignalVariance1HF1, recosignalVariance0HF1, 1, 1, "B");
13407  TH2F *recosignalVariance1HF2 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy2_HF2");
13408  TH2F *recosignalVariance0HF2 = (TH2F *)dir->FindObjectAny("h_recSignalEnergy0_HF2");
13409  TH2F *recosignalVarianceHF2 = (TH2F *)recosignalVariance1HF2->Clone("recosignalVarianceHF2");
13410  recosignalVarianceHF2->Divide(recosignalVariance1HF2, recosignalVariance0HF2, 1, 1, "B");
13411  //cout<<" Vaiance: preparation DONE *****" <<endl;
13412  //====================================================================== put Vaiance=Dispersia = Sig**2=<R**2> - (<R>)**2 into massive recosignalvarianceHF
13413  // = sum(R*R)/N - (sum(R)/N)**2
13414  for (int jeta = 0; jeta < njeta; jeta++) {
13415  //preparation for PHI normalization:
13416  double sumrecosignalHF0 = 0;
13417  int nsumrecosignalHF0 = 0;
13418  double sumrecosignalHF1 = 0;
13419  int nsumrecosignalHF1 = 0;
13420  for (int jphi = 0; jphi < njphi; jphi++) {
13421  recosignalvarianceHF[0][jeta][jphi] = recosignalVarianceHF1->GetBinContent(jeta + 1, jphi + 1);
13422  recosignalvarianceHF[1][jeta][jphi] = recosignalVarianceHF2->GetBinContent(jeta + 1, jphi + 1);
13423  if (recosignalvarianceHF[0][jeta][jphi] > 0.) {
13424  sumrecosignalHF0 += recosignalvarianceHF[0][jeta][jphi];
13425  ++nsumrecosignalHF0;
13426  }
13427  if (recosignalvarianceHF[1][jeta][jphi] > 0.) {
13428  sumrecosignalHF1 += recosignalvarianceHF[1][jeta][jphi];
13429  ++nsumrecosignalHF1;
13430  }
13431  } // phi
13432  // PHI normalization :
13433  for (int jphi = 0; jphi < njphi; jphi++) {
13434  if (recosignalvarianceHF[0][jeta][jphi] > 0.)
13435  recosignalvarianceHF[0][jeta][jphi] /= (sumrecosignalHF0 / nsumrecosignalHF0);
13436  if (recosignalvarianceHF[1][jeta][jphi] > 0.)
13437  recosignalvarianceHF[1][jeta][jphi] /= (sumrecosignalHF1 / nsumrecosignalHF1);
13438  } // phi
13439  // recosignalvarianceHF (D) = sum(R*R)/N - (sum(R)/N)**2
13440  for (int jphi = 0; jphi < njphi; jphi++) {
13441  // cout<<"12 12 12 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
13442  recosignalvarianceHF[0][jeta][jphi] -= arecosignalHF[0][jeta][jphi] * arecosignalHF[0][jeta][jphi];
13443  recosignalvarianceHF[0][jeta][jphi] = fabs(recosignalvarianceHF[0][jeta][jphi]);
13444  recosignalvarianceHF[1][jeta][jphi] -= arecosignalHF[1][jeta][jphi] * arecosignalHF[1][jeta][jphi];
13445  recosignalvarianceHF[1][jeta][jphi] = fabs(recosignalvarianceHF[1][jeta][jphi]);
13446  }
13447  }
13448  //cout<<" Vaiance: DONE*****" <<endl;
13449  //------------------------ 2D-eta/phi-plot: D, averaged over depthfs
13450  //======================================================================
13451  //======================================================================
13452  //cout<<" R2D-eta/phi-plot: D, averaged over depthfs *****" <<endl;
13453  c1x1->Clear();
13455  c1x0->Divide(1, 1);
13456  c1x0->cd(1);
13457  TH2F *DefzDrecosignalHF42D = new TH2F("DefzDrecosignalHF42D", "", neta, -41., 41., nphi, 0., 72.);
13458  TH2F *DefzDrecosignalHF42D0 = new TH2F("DefzDrecosignalHF42D0", "", neta, -41., 41., nphi, 0., 72.);
13459  TH2F *DefzDrecosignalHF42DF = (TH2F *)DefzDrecosignalHF42D0->Clone("DefzDrecosignalHF42DF");
13460  for (int i = 0; i < ndepth; i++) {
13461  for (int jeta = 0; jeta < neta; jeta++) {
13462  for (int jphi = 0; jphi < nphi; jphi++) {
13463  double ccc1 = recosignalvarianceHF[i][jeta][jphi];
13464  int k2plot = jeta - 41;
13465  int kkk = k2plot; //if(k2plot >0 kkk=k2plot+1; //-41 +41 !=0
13466  if (arecosignalHF[i][jeta][jphi] > 0.) {
13467  DefzDrecosignalHF42D->Fill(kkk, jphi, ccc1);
13468  DefzDrecosignalHF42D0->Fill(kkk, jphi, 1.);
13469  }
13470  }
13471  }
13472  }
13473  DefzDrecosignalHF42DF->Divide(DefzDrecosignalHF42D, DefzDrecosignalHF42D0, 1, 1, "B"); // average A
13474  // DefzDrecosignalHF1->Sumw2();
13475  gPad->SetGridy();
13476  gPad->SetGridx(); // gPad->SetLogz();
13477  DefzDrecosignalHF42DF->SetMarkerStyle(20);
13478  DefzDrecosignalHF42DF->SetMarkerSize(0.4);
13479  DefzDrecosignalHF42DF->GetZaxis()->SetLabelSize(0.08);
13480  DefzDrecosignalHF42DF->SetXTitle("<D>_depth #eta \b");
13481  DefzDrecosignalHF42DF->SetYTitle(" #phi \b");
13482  DefzDrecosignalHF42DF->SetZTitle("<D>_depth \b");
13483  DefzDrecosignalHF42DF->SetMarkerColor(2);
13484  DefzDrecosignalHF42DF->SetLineColor(
13485  0); // DefzDrecosignalHF42DF->SetMaximum(1.000); // DefzDrecosignalHF42DF->SetMinimum(1.0);
13486  DefzDrecosignalHF42DF->Draw("COLZ");
13488  c1x0->Update();
13489  c1x0->Print("DrecosignalGeneralD2PhiSymmetryHF.png");
13490  c1x0->Clear();
13491  // clean-up
13492  if (DefzDrecosignalHF42D)
13493  delete DefzDrecosignalHF42D;
13494  if (DefzDrecosignalHF42D0)
13495  delete DefzDrecosignalHF42D0;
13496  if (DefzDrecosignalHF42DF)
13497  delete DefzDrecosignalHF42DF;
13498  //====================================================================== 1D plot: D vs phi , averaged over depthfs & eta
13499  //======================================================================
13500  //cout<<" 1D plot: D vs phi , averaged over depthfs & eta *****" <<endl;
13501  c1x1->Clear();
13503  c1x1->Divide(1, 1);
13504  c1x1->cd(1);
13505  TH1F *DefzDrecosignalHF41D = new TH1F("DefzDrecosignalHF41D", "", nphi, 0., 72.);
13506  TH1F *DefzDrecosignalHF41D0 = new TH1F("DefzDrecosignalHF41D0", "", nphi, 0., 72.);
13507  TH1F *DefzDrecosignalHF41DF = (TH1F *)DefzDrecosignalHF41D0->Clone("DefzDrecosignalHF41DF");
13508 
13509  for (int jphi = 0; jphi < nphi; jphi++) {
13510  for (int jeta = 0; jeta < neta; jeta++) {
13511  for (int i = 0; i < ndepth; i++) {
13512  double ccc1 = recosignalvarianceHF[i][jeta][jphi];
13513  if (arecosignalHF[i][jeta][jphi] > 0.) {
13514  DefzDrecosignalHF41D->Fill(jphi, ccc1);
13515  DefzDrecosignalHF41D0->Fill(jphi, 1.);
13516  }
13517  }
13518  }
13519  }
13520  // DefzDrecosignalHF41D->Sumw2();DefzDrecosignalHF41D0->Sumw2();
13521 
13522  DefzDrecosignalHF41DF->Divide(
13523  DefzDrecosignalHF41D, DefzDrecosignalHF41D0, 1, 1, "B"); // R averaged over depthfs & eta
13524  DefzDrecosignalHF41D0->Sumw2();
13525  // for (int jphi=1;jphi<73;jphi++) {DefzDrecosignalHF41DF->SetBinError(jphi,0.01);}
13526  gPad->SetGridy();
13527  gPad->SetGridx(); // gPad->SetLogz();
13528  DefzDrecosignalHF41DF->SetMarkerStyle(20);
13529  DefzDrecosignalHF41DF->SetMarkerSize(1.4);
13530  DefzDrecosignalHF41DF->GetZaxis()->SetLabelSize(0.08);
13531  DefzDrecosignalHF41DF->SetXTitle("#phi \b");
13532  DefzDrecosignalHF41DF->SetYTitle(" <D> \b");
13533  DefzDrecosignalHF41DF->SetZTitle("<D>_PHI - AllDepthfs \b");
13534  DefzDrecosignalHF41DF->SetMarkerColor(4);
13535  DefzDrecosignalHF41DF->SetLineColor(
13536  4); // DefzDrecosignalHF41DF->SetMinimum(0.8); DefzDrecosignalHF41DF->SetMinimum(-0.015);
13537  DefzDrecosignalHF41DF->Draw("Error");
13539  c1x1->Update();
13540  c1x1->Print("DrecosignalGeneralD1PhiSymmetryHF.png");
13541  c1x1->Clear();
13542  // clean-up
13543  if (DefzDrecosignalHF41D)
13544  delete DefzDrecosignalHF41D;
13545  if (DefzDrecosignalHF41D0)
13546  delete DefzDrecosignalHF41D0;
13547  if (DefzDrecosignalHF41DF)
13548  delete DefzDrecosignalHF41DF;
13549  //========================================================================================== 14
13550  //======================================================================
13551  //======================================================================1D plot: D vs phi , different eta, depth=1
13552  //cout<<" 1D plot: D vs phi , different eta, depth=1 *****" <<endl;
13553  c3x5->Clear();
13555  c3x5->Divide(3, 5);
13556  c3x5->cd(1);
13557  int kcountHFpositivedirectionRecosignalD1 = 1;
13558  TH1F *h2CeffHFpositivedirectionRecosignalD1 = new TH1F("h2CeffHFpositivedirectionRecosignalD1", "", nphi, 0., 72.);
13559 
13560  for (int jeta = 0; jeta < njeta; jeta++) {
13561  // positivedirectionRecosignalD:
13562  if (jeta - 41 >= 0) {
13563  // for (int i=0;i<ndepth;i++) {
13564  // depth=1
13565  for (int i = 0; i < 1; i++) {
13566  TH1F *HFpositivedirectionRecosignalD1 = (TH1F *)h2CeffHFpositivedirectionRecosignalD1->Clone("twod1");
13567 
13568  float ccctest = 0; // to avoid empty massive elements
13569  for (int jphi = 0; jphi < nphi; jphi++) {
13570  double ccc1 = recosignalvarianceHF[i][jeta][jphi];
13571  if (arecosignalHF[i][jeta][jphi] > 0.) {
13572  HFpositivedirectionRecosignalD1->Fill(jphi, ccc1);
13573  ccctest = 1.; //HFpositivedirectionRecosignalD1->SetBinError(i,0.01);
13574  }
13575  } // for jphi
13576  if (ccctest > 0.) {
13577  //cout<<"1414 kcountHFpositivedirectionRecosignalD1 = "<<kcountHFpositivedirectionRecosignalD1 <<" jeta-41= "<< jeta-41 <<endl;
13578  c3x5->cd(kcountHFpositivedirectionRecosignalD1);
13579  HFpositivedirectionRecosignalD1->SetMarkerStyle(20);
13580  HFpositivedirectionRecosignalD1->SetMarkerSize(0.4);
13581  HFpositivedirectionRecosignalD1->GetYaxis()->SetLabelSize(0.04);
13582  HFpositivedirectionRecosignalD1->SetXTitle("HFpositivedirectionRecosignalD1 \b");
13583  HFpositivedirectionRecosignalD1->SetMarkerColor(2);
13584  HFpositivedirectionRecosignalD1->SetLineColor(0);
13585  gPad->SetGridy();
13586  gPad->SetGridx();
13587  // gPad->SetLogy();
13588  if (kcountHFpositivedirectionRecosignalD1 == 1)
13589  HFpositivedirectionRecosignalD1->SetXTitle("D for HF+ jeta = 28; depth = 1 \b");
13590  if (kcountHFpositivedirectionRecosignalD1 == 2)
13591  HFpositivedirectionRecosignalD1->SetXTitle("D for HF+ jeta = 29; depth = 1 \b");
13592  if (kcountHFpositivedirectionRecosignalD1 == 3)
13593  HFpositivedirectionRecosignalD1->SetXTitle("D for HF+ jeta = 30; depth = 1 \b");
13594  if (kcountHFpositivedirectionRecosignalD1 == 4)
13595  HFpositivedirectionRecosignalD1->SetXTitle("D for HF+ jeta = 31; depth = 1 \b");
13596  if (kcountHFpositivedirectionRecosignalD1 == 5)
13597  HFpositivedirectionRecosignalD1->SetXTitle("D for HF+ jeta = 32; depth = 1 \b");
13598  if (kcountHFpositivedirectionRecosignalD1 == 6)
13599  HFpositivedirectionRecosignalD1->SetXTitle("D for HF+ jeta = 33; depth = 1 \b");
13600  if (kcountHFpositivedirectionRecosignalD1 == 7)
13601  HFpositivedirectionRecosignalD1->SetXTitle("D for HF+ jeta = 34; depth = 1 \b");
13602  if (kcountHFpositivedirectionRecosignalD1 == 8)
13603  HFpositivedirectionRecosignalD1->SetXTitle("D for HF+ jeta = 35; depth = 1 \b");
13604  if (kcountHFpositivedirectionRecosignalD1 == 9)
13605  HFpositivedirectionRecosignalD1->SetXTitle("D for HF+ jeta = 36; depth = 1 \b");
13606  if (kcountHFpositivedirectionRecosignalD1 == 10)
13607  HFpositivedirectionRecosignalD1->SetXTitle("D for HF+ jeta = 37; depth = 1 \b");
13608  if (kcountHFpositivedirectionRecosignalD1 == 11)
13609  HFpositivedirectionRecosignalD1->SetXTitle("D for HF+ jeta = 38; depth = 1 \b");
13610  if (kcountHFpositivedirectionRecosignalD1 == 12)
13611  HFpositivedirectionRecosignalD1->SetXTitle("D for HF+ jeta = 39; depth = 1 \b");
13612  if (kcountHFpositivedirectionRecosignalD1 == 13)
13613  HFpositivedirectionRecosignalD1->SetXTitle("D for HF+ jeta = 40; depth = 1 \b");
13614  HFpositivedirectionRecosignalD1->Draw("Error");
13615  kcountHFpositivedirectionRecosignalD1++;
13616  if (kcountHFpositivedirectionRecosignalD1 > 13)
13617  break; // 4x6 = 24
13618  } //ccctest>0
13619 
13620  } // for i
13621  } //if(jeta-41 >= 0)
13622  } //for jeta
13624  c3x5->Update();
13625  c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth1HF.png");
13626  c3x5->Clear();
13627  // clean-up
13628  if (h2CeffHFpositivedirectionRecosignalD1)
13629  delete h2CeffHFpositivedirectionRecosignalD1;
13630  //========================================================================================== 15
13631  //======================================================================
13632  //======================================================================1D plot: D vs phi , different eta, depth=2
13633  //cout<<" 1D plot: D vs phi , different eta, depth=2 *****" <<endl;
13634  c3x5->Clear();
13635  c3x5->Divide(3, 5);
13636  c3x5->cd(1);
13637  int kcountHFpositivedirectionRecosignalD2 = 1;
13638  TH1F *h2CeffHFpositivedirectionRecosignalD2 = new TH1F("h2CeffHFpositivedirectionRecosignalD2", "", nphi, 0., 72.);
13639 
13640  for (int jeta = 0; jeta < njeta; jeta++) {
13641  // positivedirectionRecosignalD:
13642  if (jeta - 41 >= 0) {
13643  // for (int i=0;i<ndepth;i++) {
13644  // depth=2
13645  for (int i = 1; i < 2; i++) {
13646  TH1F *HFpositivedirectionRecosignalD2 = (TH1F *)h2CeffHFpositivedirectionRecosignalD2->Clone("twod1");
13647 
13648  float ccctest = 0; // to avoid empty massive elements
13649  for (int jphi = 0; jphi < nphi; jphi++) {
13650  double ccc1 = recosignalvarianceHF[i][jeta][jphi];
13651  if (arecosignalHF[i][jeta][jphi] > 0.) {
13652  HFpositivedirectionRecosignalD2->Fill(jphi, ccc1);
13653  ccctest = 1.; //HFpositivedirectionRecosignalD2->SetBinError(i,0.01);
13654  }
13655  } // for jphi
13656  if (ccctest > 0.) {
13657  //cout<<"1515 kcountHFpositivedirectionRecosignalD2 = "<<kcountHFpositivedirectionRecosignalD2 <<" jeta-41= "<< jeta-41 <<endl;
13658  c3x5->cd(kcountHFpositivedirectionRecosignalD2);
13659  HFpositivedirectionRecosignalD2->SetMarkerStyle(20);
13660  HFpositivedirectionRecosignalD2->SetMarkerSize(0.4);
13661  HFpositivedirectionRecosignalD2->GetYaxis()->SetLabelSize(0.04);
13662  HFpositivedirectionRecosignalD2->SetXTitle("HFpositivedirectionRecosignalD2 \b");
13663  HFpositivedirectionRecosignalD2->SetMarkerColor(2);
13664  HFpositivedirectionRecosignalD2->SetLineColor(0);
13665  gPad->SetGridy();
13666  gPad->SetGridx();
13667  // gPad->SetLogy();
13668  if (kcountHFpositivedirectionRecosignalD2 == 1)
13669  HFpositivedirectionRecosignalD2->SetXTitle("D for HF+ jeta = 28; depth = 2 \b");
13670  if (kcountHFpositivedirectionRecosignalD2 == 2)
13671  HFpositivedirectionRecosignalD2->SetXTitle("D for HF+ jeta = 29; depth = 2 \b");
13672  if (kcountHFpositivedirectionRecosignalD2 == 3)
13673  HFpositivedirectionRecosignalD2->SetXTitle("D for HF+ jeta = 30; depth = 2 \b");
13674  if (kcountHFpositivedirectionRecosignalD2 == 4)
13675  HFpositivedirectionRecosignalD2->SetXTitle("D for HF+ jeta = 31; depth = 2 \b");
13676  if (kcountHFpositivedirectionRecosignalD2 == 5)
13677  HFpositivedirectionRecosignalD2->SetXTitle("D for HF+ jeta = 32; depth = 2 \b");
13678  if (kcountHFpositivedirectionRecosignalD2 == 6)
13679  HFpositivedirectionRecosignalD2->SetXTitle("D for HF+ jeta = 33; depth = 2 \b");
13680  if (kcountHFpositivedirectionRecosignalD2 == 7)
13681  HFpositivedirectionRecosignalD2->SetXTitle("D for HF+ jeta = 34; depth = 2 \b");
13682  if (kcountHFpositivedirectionRecosignalD2 == 8)
13683  HFpositivedirectionRecosignalD2->SetXTitle("D for HF+ jeta = 35; depth = 2 \b");
13684  if (kcountHFpositivedirectionRecosignalD2 == 9)
13685  HFpositivedirectionRecosignalD2->SetXTitle("D for HF+ jeta = 36; depth = 2 \b");
13686  if (kcountHFpositivedirectionRecosignalD2 == 10)
13687  HFpositivedirectionRecosignalD2->SetXTitle("D for HF+ jeta = 37; depth = 2 \b");
13688  if (kcountHFpositivedirectionRecosignalD2 == 11)
13689  HFpositivedirectionRecosignalD2->SetXTitle("D for HF+ jeta = 38; depth = 2 \b");
13690  if (kcountHFpositivedirectionRecosignalD2 == 12)
13691  HFpositivedirectionRecosignalD2->SetXTitle("D for HF+ jeta = 39; depth = 2 \b");
13692  if (kcountHFpositivedirectionRecosignalD2 == 13)
13693  HFpositivedirectionRecosignalD2->SetXTitle("D for HF+ jeta = 40; depth = 2 \b");
13694  HFpositivedirectionRecosignalD2->Draw("Error");
13695  kcountHFpositivedirectionRecosignalD2++;
13696  if (kcountHFpositivedirectionRecosignalD2 > 13)
13697  break; // 4x6 = 24
13698  } //ccctest>0
13699 
13700  } // for i
13701  } //if(jeta-41 >= 0)
13702  } //for jeta
13704  c3x5->Update();
13705  c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth2HF.png");
13706  c3x5->Clear();
13707  // clean-up
13708  if (h2CeffHFpositivedirectionRecosignalD2)
13709  delete h2CeffHFpositivedirectionRecosignalD2;
13710  //========================================================================================== 22222214
13711  //======================================================================
13712  //======================================================================1D plot: D vs phi , different eta, depth=1
13713  //cout<<" 1D plot: D vs phi , different eta, depth=1 *****" <<endl;
13714  c3x5->Clear();
13716  c3x5->Divide(3, 5);
13717  c3x5->cd(1);
13718  int kcountHFnegativedirectionRecosignalD1 = 1;
13719  TH1F *h2CeffHFnegativedirectionRecosignalD1 = new TH1F("h2CeffHFnegativedirectionRecosignalD1", "", nphi, 0., 72.);
13720 
13721  for (int jeta = 0; jeta < njeta; jeta++) {
13722  // negativedirectionRecosignalD:
13723  if (jeta - 41 < 0) {
13724  // for (int i=0;i<ndepth;i++) {
13725  // depth=1
13726  for (int i = 0; i < 1; i++) {
13727  TH1F *HFnegativedirectionRecosignalD1 = (TH1F *)h2CeffHFnegativedirectionRecosignalD1->Clone("twod1");
13728 
13729  float ccctest = 0; // to avoid empty massive elements
13730  for (int jphi = 0; jphi < nphi; jphi++) {
13731  double ccc1 = recosignalvarianceHF[i][jeta][jphi];
13732  if (arecosignalHF[i][jeta][jphi] > 0.) {
13733  HFnegativedirectionRecosignalD1->Fill(jphi, ccc1);
13734  ccctest = 1.; //HFnegativedirectionRecosignalD1->SetBinError(i,0.01);
13735  }
13736  } // for jphi
13737  if (ccctest > 0.) {
13738  //cout<<"1414 kcountHFnegativedirectionRecosignalD1 = "<<kcountHFnegativedirectionRecosignalD1 <<" jeta-41= "<< jeta-41 <<endl;
13739  c3x5->cd(kcountHFnegativedirectionRecosignalD1);
13740  HFnegativedirectionRecosignalD1->SetMarkerStyle(20);
13741  HFnegativedirectionRecosignalD1->SetMarkerSize(0.4);
13742  HFnegativedirectionRecosignalD1->GetYaxis()->SetLabelSize(0.04);
13743  HFnegativedirectionRecosignalD1->SetXTitle("HFnegativedirectionRecosignalD1 \b");
13744  HFnegativedirectionRecosignalD1->SetMarkerColor(2);
13745  HFnegativedirectionRecosignalD1->SetLineColor(0);
13746  gPad->SetGridy();
13747  gPad->SetGridx();
13748  // gPad->SetLogy();
13749  if (kcountHFnegativedirectionRecosignalD1 == 1)
13750  HFnegativedirectionRecosignalD1->SetXTitle("D for HF- jeta =-41; depth = 1 \b");
13751  if (kcountHFnegativedirectionRecosignalD1 == 2)
13752  HFnegativedirectionRecosignalD1->SetXTitle("D for HF- jeta =-40; depth = 1 \b");
13753  if (kcountHFnegativedirectionRecosignalD1 == 3)
13754  HFnegativedirectionRecosignalD1->SetXTitle("D for HF- jeta =-39; depth = 1 \b");
13755  if (kcountHFnegativedirectionRecosignalD1 == 4)
13756  HFnegativedirectionRecosignalD1->SetXTitle("D for HF- jeta =-38; depth = 1 \b");
13757  if (kcountHFnegativedirectionRecosignalD1 == 5)
13758  HFnegativedirectionRecosignalD1->SetXTitle("D for HF- jeta =-37; depth = 1 \b");
13759  if (kcountHFnegativedirectionRecosignalD1 == 6)
13760  HFnegativedirectionRecosignalD1->SetXTitle("D for HF- jeta =-36; depth = 1 \b");
13761  if (kcountHFnegativedirectionRecosignalD1 == 7)
13762  HFnegativedirectionRecosignalD1->SetXTitle("D for HF- jeta =-35; depth = 1 \b");
13763  if (kcountHFnegativedirectionRecosignalD1 == 8)
13764  HFnegativedirectionRecosignalD1->SetXTitle("D for HF- jeta =-34; depth = 1 \b");
13765  if (kcountHFnegativedirectionRecosignalD1 == 9)
13766  HFnegativedirectionRecosignalD1->SetXTitle("D for HF- jeta =-33; depth = 1 \b");
13767  if (kcountHFnegativedirectionRecosignalD1 == 10)
13768  HFnegativedirectionRecosignalD1->SetXTitle("D for HF- jeta =-32; depth = 1 \b");
13769  if (kcountHFnegativedirectionRecosignalD1 == 11)
13770  HFnegativedirectionRecosignalD1->SetXTitle("D for HF- jeta =-31; depth = 1 \b");
13771  if (kcountHFnegativedirectionRecosignalD1 == 12)
13772  HFnegativedirectionRecosignalD1->SetXTitle("D for HF- jeta =-30; depth = 1 \b");
13773  if (kcountHFnegativedirectionRecosignalD1 == 13)
13774  HFnegativedirectionRecosignalD1->SetXTitle("D for HF- jeta =-29; depth = 1 \b");
13775  HFnegativedirectionRecosignalD1->Draw("Error");
13776  kcountHFnegativedirectionRecosignalD1++;
13777  if (kcountHFnegativedirectionRecosignalD1 > 13)
13778  break; // 4x6 = 24
13779  } //ccctest>0
13780 
13781  } // for i
13782  } //if(jeta-41< 0)
13783  } //for jeta
13785  c3x5->Update();
13786  c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth1HF.png");
13787  c3x5->Clear();
13788  // clean-up
13789  if (h2CeffHFnegativedirectionRecosignalD1)
13790  delete h2CeffHFnegativedirectionRecosignalD1;
13791  //========================================================================================== 22222215
13792  //======================================================================
13793  //======================================================================1D plot: D vs phi , different eta, depth=2
13794  //cout<<" 1D plot: D vs phi , different eta, depth=2 *****" <<endl;
13795  c3x5->Clear();
13796  c3x5->Divide(3, 5);
13797  c3x5->cd(1);
13798  int kcountHFnegativedirectionRecosignalD2 = 1;
13799  TH1F *h2CeffHFnegativedirectionRecosignalD2 = new TH1F("h2CeffHFnegativedirectionRecosignalD2", "", nphi, 0., 72.);
13800 
13801  for (int jeta = 0; jeta < njeta; jeta++) {
13802  // negativedirectionRecosignalD:
13803  if (jeta - 41 < 0) {
13804  // for (int i=0;i<ndepth;i++) {
13805  // depth=2
13806  for (int i = 1; i < 2; i++) {
13807  TH1F *HFnegativedirectionRecosignalD2 = (TH1F *)h2CeffHFnegativedirectionRecosignalD2->Clone("twod1");
13808 
13809  float ccctest = 0; // to avoid empty massive elements
13810  for (int jphi = 0; jphi < nphi; jphi++) {
13811  double ccc1 = recosignalvarianceHF[i][jeta][jphi];
13812  if (arecosignalHF[i][jeta][jphi] > 0.) {
13813  HFnegativedirectionRecosignalD2->Fill(jphi, ccc1);
13814  ccctest = 1.; //HFnegativedirectionRecosignalD2->SetBinError(i,0.01);
13815  }
13816  } // for jphi
13817  if (ccctest > 0.) {
13818  //cout<<"1515 kcountHFnegativedirectionRecosignalD2 = "<<kcountHFnegativedirectionRecosignalD2 <<" jeta-41= "<< jeta-41 <<endl;
13819  c3x5->cd(kcountHFnegativedirectionRecosignalD2);
13820  HFnegativedirectionRecosignalD2->SetMarkerStyle(20);
13821  HFnegativedirectionRecosignalD2->SetMarkerSize(0.4);
13822  HFnegativedirectionRecosignalD2->GetYaxis()->SetLabelSize(0.04);
13823  HFnegativedirectionRecosignalD2->SetXTitle("HFnegativedirectionRecosignalD2 \b");
13824  HFnegativedirectionRecosignalD2->SetMarkerColor(2);
13825  HFnegativedirectionRecosignalD2->SetLineColor(0);
13826  gPad->SetGridy();
13827  gPad->SetGridx();
13828  // gPad->SetLogy();
13829  if (kcountHFnegativedirectionRecosignalD2 == 1)
13830  HFnegativedirectionRecosignalD2->SetXTitle("D for HF- jeta =-41; depth = 2 \b");
13831  if (kcountHFnegativedirectionRecosignalD2 == 2)
13832  HFnegativedirectionRecosignalD2->SetXTitle("D for HF- jeta =-40; depth = 2 \b");
13833  if (kcountHFnegativedirectionRecosignalD2 == 3)
13834  HFnegativedirectionRecosignalD2->SetXTitle("D for HF- jeta =-39; depth = 2 \b");
13835  if (kcountHFnegativedirectionRecosignalD2 == 4)
13836  HFnegativedirectionRecosignalD2->SetXTitle("D for HF- jeta =-38; depth = 2 \b");
13837  if (kcountHFnegativedirectionRecosignalD2 == 5)
13838  HFnegativedirectionRecosignalD2->SetXTitle("D for HF- jeta =-37; depth = 2 \b");
13839  if (kcountHFnegativedirectionRecosignalD2 == 6)
13840  HFnegativedirectionRecosignalD2->SetXTitle("D for HF- jeta =-36; depth = 2 \b");
13841  if (kcountHFnegativedirectionRecosignalD2 == 7)
13842  HFnegativedirectionRecosignalD2->SetXTitle("D for HF- jeta =-35; depth = 2 \b");
13843  if (kcountHFnegativedirectionRecosignalD2 == 8)
13844  HFnegativedirectionRecosignalD2->SetXTitle("D for HF- jeta =-34; depth = 2 \b");
13845  if (kcountHFnegativedirectionRecosignalD2 == 9)
13846  HFnegativedirectionRecosignalD2->SetXTitle("D for HF- jeta =-33; depth = 2 \b");
13847  if (kcountHFnegativedirectionRecosignalD2 == 10)
13848  HFnegativedirectionRecosignalD2->SetXTitle("D for HF- jeta =-32; depth = 2 \b");
13849  if (kcountHFnegativedirectionRecosignalD2 == 11)
13850  HFnegativedirectionRecosignalD2->SetXTitle("D for HF- jeta =-31; depth = 2 \b");
13851  if (kcountHFnegativedirectionRecosignalD2 == 12)
13852  HFnegativedirectionRecosignalD2->SetXTitle("D for HF- jeta =-30; depth = 2 \b");
13853  if (kcountHFnegativedirectionRecosignalD2 == 13)
13854  HFnegativedirectionRecosignalD2->SetXTitle("D for HF- jeta =-29; depth = 2 \b");
13855  HFnegativedirectionRecosignalD2->Draw("Error");
13856  kcountHFnegativedirectionRecosignalD2++;
13857  if (kcountHFnegativedirectionRecosignalD2 > 13)
13858  break; // 4x6 = 24
13859  } //ccctest>0
13860 
13861  } // for i
13862  } //if(jeta-41< 0)
13863  } //for jeta
13865  c3x5->Update();
13866  c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth2HF.png");
13867  c3x5->Clear();
13868  // clean-up
13869  if (h2CeffHFnegativedirectionRecosignalD2)
13870  delete h2CeffHFnegativedirectionRecosignalD2;
13871 
13872  //===================================================================== END of Recosignal HF for phi-symmetry
13873  //===================================================================== END of Recosignal HF for phi-symmetry
13874  //===================================================================== END of Recosignal HF for phi-symmetry
13875  //============================================================================================================ END of Recosignal for phi-symmetry
13876  //============================================================================================================ END of Recosignal for phi-symmetry
13877  //============================================================================================================ END of Recosignal for phi-symmetry
13878 
13885  // int k_max[5]={0,4,7,4,4}; // maximum depth for each subdet
13886  //ndepth = k_max[5];
13887  ndepth = 4;
13888  double areconoiseHB[ndepth][njeta][njphi];
13889  double breconoiseHB[ndepth][njeta][njphi];
13890  double reconoisevarianceHB[ndepth][njeta][njphi];
13891  // RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR: Reconoise HB recNoiseEnergy
13892  TH2F *recNoiseEnergy1HB1 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy1_HB1");
13893  TH2F *recNoiseEnergy0HB1 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HB1");
13894  TH2F *recNoiseEnergyHB1 = (TH2F *)recNoiseEnergy1HB1->Clone("recNoiseEnergyHB1");
13895  recNoiseEnergyHB1->Divide(recNoiseEnergy1HB1, recNoiseEnergy0HB1, 1, 1, "B");
13896  TH2F *recNoiseEnergy1HB2 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy1_HB2");
13897  TH2F *recNoiseEnergy0HB2 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HB2");
13898  TH2F *recNoiseEnergyHB2 = (TH2F *)recNoiseEnergy1HB2->Clone("recNoiseEnergyHB2");
13899  recNoiseEnergyHB2->Divide(recNoiseEnergy1HB2, recNoiseEnergy0HB2, 1, 1, "B");
13900  TH2F *recNoiseEnergy1HB3 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy1_HB3");
13901  TH2F *recNoiseEnergy0HB3 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HB3");
13902  TH2F *recNoiseEnergyHB3 = (TH2F *)recNoiseEnergy1HB3->Clone("recNoiseEnergyHB3");
13903  recNoiseEnergyHB3->Divide(recNoiseEnergy1HB3, recNoiseEnergy0HB3, 1, 1, "B");
13904  TH2F *recNoiseEnergy1HB4 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy1_HB4");
13905  TH2F *recNoiseEnergy0HB4 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HB4");
13906  TH2F *recNoiseEnergyHB4 = (TH2F *)recNoiseEnergy1HB4->Clone("recNoiseEnergyHB4");
13907  recNoiseEnergyHB4->Divide(recNoiseEnergy1HB4, recNoiseEnergy0HB4, 1, 1, "B");
13908  for (int jeta = 0; jeta < njeta; jeta++) {
13909  if ((jeta - 41 >= -16 && jeta - 41 <= -1) || (jeta - 41 >= 0 && jeta - 41 <= 15)) {
13910  //====================================================================== PHI normalization & put R into massive areconoiseHB
13911  //preparation for PHI normalization:
13912  double sumreconoiseHB0 = 0;
13913  int nsumreconoiseHB0 = 0;
13914  double sumreconoiseHB1 = 0;
13915  int nsumreconoiseHB1 = 0;
13916  double sumreconoiseHB2 = 0;
13917  int nsumreconoiseHB2 = 0;
13918  double sumreconoiseHB3 = 0;
13919  int nsumreconoiseHB3 = 0;
13920  for (int jphi = 0; jphi < njphi; jphi++) {
13921  areconoiseHB[0][jeta][jphi] = recNoiseEnergyHB1->GetBinContent(jeta + 1, jphi + 1);
13922  areconoiseHB[1][jeta][jphi] = recNoiseEnergyHB2->GetBinContent(jeta + 1, jphi + 1);
13923  areconoiseHB[2][jeta][jphi] = recNoiseEnergyHB3->GetBinContent(jeta + 1, jphi + 1);
13924  areconoiseHB[3][jeta][jphi] = recNoiseEnergyHB4->GetBinContent(jeta + 1, jphi + 1);
13925  breconoiseHB[0][jeta][jphi] = recNoiseEnergyHB1->GetBinContent(jeta + 1, jphi + 1);
13926  breconoiseHB[1][jeta][jphi] = recNoiseEnergyHB2->GetBinContent(jeta + 1, jphi + 1);
13927  breconoiseHB[2][jeta][jphi] = recNoiseEnergyHB3->GetBinContent(jeta + 1, jphi + 1);
13928  breconoiseHB[3][jeta][jphi] = recNoiseEnergyHB4->GetBinContent(jeta + 1, jphi + 1);
13929  if (areconoiseHB[0][jeta][jphi] != 0.) {
13930  sumreconoiseHB0 += areconoiseHB[0][jeta][jphi];
13931  ++nsumreconoiseHB0;
13932  }
13933  if (areconoiseHB[1][jeta][jphi] != 0.) {
13934  sumreconoiseHB1 += areconoiseHB[1][jeta][jphi];
13935  ++nsumreconoiseHB1;
13936  }
13937  if (areconoiseHB[2][jeta][jphi] != 0.) {
13938  sumreconoiseHB2 += areconoiseHB[2][jeta][jphi];
13939  ++nsumreconoiseHB2;
13940  }
13941  if (areconoiseHB[3][jeta][jphi] != 0.) {
13942  sumreconoiseHB3 += areconoiseHB[3][jeta][jphi];
13943  ++nsumreconoiseHB3;
13944  }
13945  } // phi
13946  // PHI normalization: DIF
13947  for (int jphi = 0; jphi < njphi; jphi++) {
13948  if (sumreconoiseHB0 != 0.)
13949  breconoiseHB[0][jeta][jphi] -= (sumreconoiseHB0 / nsumreconoiseHB0);
13950  if (sumreconoiseHB1 != 0.)
13951  breconoiseHB[1][jeta][jphi] -= (sumreconoiseHB1 / nsumreconoiseHB1);
13952  if (sumreconoiseHB2 != 0.)
13953  breconoiseHB[2][jeta][jphi] -= (sumreconoiseHB2 / nsumreconoiseHB2);
13954  if (sumreconoiseHB3 != 0.)
13955  breconoiseHB[3][jeta][jphi] -= (sumreconoiseHB3 / nsumreconoiseHB3);
13956  } // phi
13957  // PHI normalization: R
13958  for (int jphi = 0; jphi < njphi; jphi++) {
13959  if (areconoiseHB[0][jeta][jphi] != 0.)
13960  areconoiseHB[0][jeta][jphi] /= (sumreconoiseHB0 / nsumreconoiseHB0);
13961  if (areconoiseHB[1][jeta][jphi] != 0.)
13962  areconoiseHB[1][jeta][jphi] /= (sumreconoiseHB1 / nsumreconoiseHB1);
13963  if (areconoiseHB[2][jeta][jphi] != 0.)
13964  areconoiseHB[2][jeta][jphi] /= (sumreconoiseHB2 / nsumreconoiseHB2);
13965  if (areconoiseHB[3][jeta][jphi] != 0.)
13966  areconoiseHB[3][jeta][jphi] /= (sumreconoiseHB3 / nsumreconoiseHB3);
13967  } // phi
13968  } //if eta
13969  } //eta
13970  //------------------------ 2D-eta/phi-plot: R, averaged over depthfs
13971  //======================================================================
13972  //======================================================================
13973  //cout<<" R2D-eta/phi-plot: R, averaged over depthfs *****" <<endl;
13974  c2x1->Clear();
13976  c2x1->Divide(2, 1);
13977  c2x1->cd(1);
13978  TH2F *GefzRreconoiseHB42D = new TH2F("GefzRreconoiseHB42D", "", neta, -41., 41., nphi, 0., 72.);
13979  TH2F *GefzRreconoiseHB42D0 = new TH2F("GefzRreconoiseHB42D0", "", neta, -41., 41., nphi, 0., 72.);
13980  TH2F *GefzRreconoiseHB42DF = (TH2F *)GefzRreconoiseHB42D0->Clone("GefzRreconoiseHB42DF");
13981  for (int i = 0; i < ndepth; i++) {
13982  for (int jeta = 0; jeta < neta; jeta++) {
13983  if ((jeta - 41 >= -16 && jeta - 41 <= -1) || (jeta - 41 >= 0 && jeta - 41 <= 15)) {
13984  for (int jphi = 0; jphi < nphi; jphi++) {
13985  double ccc1 = areconoiseHB[i][jeta][jphi];
13986  int k2plot = jeta - 41;
13987  int kkk = k2plot; //if(k2plot >0 ) kkk=k2plot+1; //-41 +41 !=0
13988  if (ccc1 != 0.) {
13989  GefzRreconoiseHB42D->Fill(kkk, jphi, ccc1);
13990  GefzRreconoiseHB42D0->Fill(kkk, jphi, 1.);
13991  }
13992  }
13993  }
13994  }
13995  }
13996  GefzRreconoiseHB42DF->Divide(GefzRreconoiseHB42D, GefzRreconoiseHB42D0, 1, 1, "B"); // average A
13997  gPad->SetGridy();
13998  gPad->SetGridx(); // gPad->SetLogz();
13999  GefzRreconoiseHB42DF->SetXTitle("<R>_depth #eta \b");
14000  GefzRreconoiseHB42DF->SetYTitle(" #phi \b");
14001  GefzRreconoiseHB42DF->Draw("COLZ");
14002 
14003  c2x1->cd(2);
14004  TH1F *energyhitNoise_HB = (TH1F *)dir->FindObjectAny("h_energyhitNoise_HB");
14005  energyhitNoise_HB->SetMarkerStyle(20);
14006  energyhitNoise_HB->SetMarkerSize(0.4);
14007  energyhitNoise_HB->GetYaxis()->SetLabelSize(0.04);
14008  energyhitNoise_HB->SetXTitle("energyhitNoise_HB \b");
14009  energyhitNoise_HB->SetMarkerColor(2);
14010  energyhitNoise_HB->SetLineColor(0);
14011  gPad->SetGridy();
14012  gPad->SetGridx();
14013  energyhitNoise_HB->Draw("Error");
14014 
14016  c2x1->Update();
14017  c2x1->Print("RreconoiseGeneralD2PhiSymmetryHB.png");
14018  c2x1->Clear();
14019  // clean-up
14020  if (GefzRreconoiseHB42D)
14021  delete GefzRreconoiseHB42D;
14022  if (GefzRreconoiseHB42D0)
14023  delete GefzRreconoiseHB42D0;
14024  if (GefzRreconoiseHB42DF)
14025  delete GefzRreconoiseHB42DF;
14026  //====================================================================== 1D plot: R vs phi , averaged over depthfs & eta
14027  //======================================================================
14028  //cout<<" 1D plot: R vs phi , averaged over depthfs & eta *****" <<endl;
14029  c1x1->Clear();
14031  c1x1->Divide(1, 1);
14032  c1x1->cd(1);
14033  TH1F *GefzRreconoiseHB41D = new TH1F("GefzRreconoiseHB41D", "", nphi, 0., 72.);
14034  TH1F *GefzRreconoiseHB41D0 = new TH1F("GefzRreconoiseHB41D0", "", nphi, 0., 72.);
14035  TH1F *GefzRreconoiseHB41DF = (TH1F *)GefzRreconoiseHB41D0->Clone("GefzRreconoiseHB41DF");
14036  for (int jphi = 0; jphi < nphi; jphi++) {
14037  for (int jeta = 0; jeta < neta; jeta++) {
14038  if ((jeta - 41 >= -16 && jeta - 41 <= -1) || (jeta - 41 >= 0 && jeta - 41 <= 15)) {
14039  for (int i = 0; i < ndepth; i++) {
14040  double ccc1 = areconoiseHB[i][jeta][jphi];
14041  if (ccc1 != 0.) {
14042  GefzRreconoiseHB41D->Fill(jphi, ccc1);
14043  GefzRreconoiseHB41D0->Fill(jphi, 1.);
14044  }
14045  }
14046  }
14047  }
14048  }
14049  GefzRreconoiseHB41DF->Divide(GefzRreconoiseHB41D, GefzRreconoiseHB41D0, 1, 1, "B"); // R averaged over depthfs & eta
14050  GefzRreconoiseHB41D0->Sumw2();
14051  // for (int jphi=1;jphi<73;jphi++) {GefzRreconoiseHB41DF->SetBinError(jphi,0.01);}
14052  gPad->SetGridy();
14053  gPad->SetGridx(); // gPad->SetLogz();
14054  GefzRreconoiseHB41DF->SetMarkerStyle(20);
14055  GefzRreconoiseHB41DF->SetMarkerSize(1.4);
14056  GefzRreconoiseHB41DF->GetZaxis()->SetLabelSize(0.08);
14057  GefzRreconoiseHB41DF->SetXTitle("#phi \b");
14058  GefzRreconoiseHB41DF->SetYTitle(" <R> \b");
14059  GefzRreconoiseHB41DF->SetZTitle("<R>_PHI - AllDepthfs \b");
14060  GefzRreconoiseHB41DF->SetMarkerColor(4);
14061  GefzRreconoiseHB41DF->SetLineColor(
14062  4); //GefzRreconoiseHB41DF->SetMinimum(0.8); // GefzRreconoiseHB41DF->SetMaximum(1.000);
14063  GefzRreconoiseHB41DF->Draw("Error");
14065  c1x1->Update();
14066  c1x1->Print("RreconoiseGeneralD1PhiSymmetryHB.png");
14067  c1x1->Clear();
14068  // clean-up
14069  if (GefzRreconoiseHB41D)
14070  delete GefzRreconoiseHB41D;
14071  if (GefzRreconoiseHB41D0)
14072  delete GefzRreconoiseHB41D0;
14073  if (GefzRreconoiseHB41DF)
14074  delete GefzRreconoiseHB41DF;
14075  //========================================================================================== 4
14076  //======================================================================
14077  //======================================================================1D plot: R vs phi , different eta, depth=1
14078  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
14079  c3x5->Clear();
14081  c3x5->Divide(4, 4);
14082  c3x5->cd(1);
14083  int kcountHBpositivedirectionReconoise1 = 1;
14084  TH1F *h2CeffHBpositivedirectionReconoise1 = new TH1F("h2CeffHBpositivedirectionReconoise1", "", nphi, 0., 72.);
14085  for (int jeta = 0; jeta < njeta; jeta++) {
14086  // positivedirectionReconoise:
14087  if (jeta - 41 >= 0 && jeta - 41 <= 15) {
14088  // for (int i=0;i<ndepth;i++) {
14089  // depth=1
14090  for (int i = 0; i < 1; i++) {
14091  TH1F *HBpositivedirectionReconoise1 = (TH1F *)h2CeffHBpositivedirectionReconoise1->Clone("twod1");
14092  float ccctest = 0; // to avoid empty massive elements
14093  for (int jphi = 0; jphi < nphi; jphi++) {
14094  double ccc1 = areconoiseHB[i][jeta][jphi];
14095  if (ccc1 != 0.) {
14096  HBpositivedirectionReconoise1->Fill(jphi, ccc1);
14097  ccctest = 1.; //HBpositivedirectionReconoise1->SetBinError(i,0.01);
14098  }
14099  } // for jphi
14100  if (ccctest > 0.) {
14101  // cout<<"444 kcountHBpositivedirectionReconoise1 = "<<kcountHBpositivedirectionReconoise1 <<" jeta-41= "<< jeta-41 <<endl;
14102  c3x5->cd(kcountHBpositivedirectionReconoise1);
14103  HBpositivedirectionReconoise1->SetMarkerStyle(20);
14104  HBpositivedirectionReconoise1->SetMarkerSize(0.4);
14105  HBpositivedirectionReconoise1->GetYaxis()->SetLabelSize(0.04);
14106  HBpositivedirectionReconoise1->SetXTitle("HBpositivedirectionReconoise1 \b");
14107  HBpositivedirectionReconoise1->SetMarkerColor(2);
14108  HBpositivedirectionReconoise1->SetLineColor(0);
14109  gPad->SetGridy();
14110  gPad->SetGridx();
14111  // gPad->SetLogy();
14112  if (kcountHBpositivedirectionReconoise1 == 1)
14113  HBpositivedirectionReconoise1->SetXTitle("R for HB+ jeta = 0; depth = 1 \b");
14114  if (kcountHBpositivedirectionReconoise1 == 2)
14115  HBpositivedirectionReconoise1->SetXTitle("R for HB+ jeta = 1; depth = 1 \b");
14116  if (kcountHBpositivedirectionReconoise1 == 3)
14117  HBpositivedirectionReconoise1->SetXTitle("R for HB+ jeta = 2; depth = 1 \b");
14118  if (kcountHBpositivedirectionReconoise1 == 4)
14119  HBpositivedirectionReconoise1->SetXTitle("R for HB+ jeta = 3; depth = 1 \b");
14120  if (kcountHBpositivedirectionReconoise1 == 5)
14121  HBpositivedirectionReconoise1->SetXTitle("R for HB+ jeta = 4; depth = 1 \b");
14122  if (kcountHBpositivedirectionReconoise1 == 6)
14123  HBpositivedirectionReconoise1->SetXTitle("R for HB+ jeta = 5; depth = 1 \b");
14124  if (kcountHBpositivedirectionReconoise1 == 7)
14125  HBpositivedirectionReconoise1->SetXTitle("R for HB+ jeta = 6; depth = 1 \b");
14126  if (kcountHBpositivedirectionReconoise1 == 8)
14127  HBpositivedirectionReconoise1->SetXTitle("R for HB+ jeta = 7; depth = 1 \b");
14128  if (kcountHBpositivedirectionReconoise1 == 9)
14129  HBpositivedirectionReconoise1->SetXTitle("R for HB+ jeta = 8; depth = 1 \b");
14130  if (kcountHBpositivedirectionReconoise1 == 10)
14131  HBpositivedirectionReconoise1->SetXTitle("R for HB+ jeta = 9; depth = 1 \b");
14132  if (kcountHBpositivedirectionReconoise1 == 11)
14133  HBpositivedirectionReconoise1->SetXTitle("R for HB+ jeta = 10; depth = 1 \b");
14134  if (kcountHBpositivedirectionReconoise1 == 12)
14135  HBpositivedirectionReconoise1->SetXTitle("R for HB+ jeta = 11; depth = 1 \b");
14136  if (kcountHBpositivedirectionReconoise1 == 13)
14137  HBpositivedirectionReconoise1->SetXTitle("R for HB+ jeta = 12; depth = 1 \b");
14138  if (kcountHBpositivedirectionReconoise1 == 14)
14139  HBpositivedirectionReconoise1->SetXTitle("R for HB+ jeta = 13; depth = 1 \b");
14140  if (kcountHBpositivedirectionReconoise1 == 15)
14141  HBpositivedirectionReconoise1->SetXTitle("R for HB+ jeta = 14; depth = 1 \b");
14142  if (kcountHBpositivedirectionReconoise1 == 16)
14143  HBpositivedirectionReconoise1->SetXTitle("R for HB+ jeta = 15; depth = 1 \b");
14144  HBpositivedirectionReconoise1->Draw("Error");
14145  kcountHBpositivedirectionReconoise1++;
14146  if (kcountHBpositivedirectionReconoise1 > 16)
14147  break; //
14148  } //ccctest>0
14149 
14150  } // for i
14151  } //if(jeta-41 >= 0)
14152  } //for jeta
14154  c3x5->Update();
14155  c3x5->Print("RreconoisePositiveDirectionhistD1PhiSymmetryDepth1HB.png");
14156  c3x5->Clear();
14157  // clean-up
14158  if (h2CeffHBpositivedirectionReconoise1)
14159  delete h2CeffHBpositivedirectionReconoise1;
14160 
14161  //========================================================================================== 5
14162  //======================================================================
14163  //======================================================================1D plot: R vs phi , different eta, depth=2
14164  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
14165  c3x5->Clear();
14167  c3x5->Divide(4, 4);
14168  c3x5->cd(1);
14169  int kcountHBpositivedirectionReconoise2 = 1;
14170  TH1F *h2CeffHBpositivedirectionReconoise2 = new TH1F("h2CeffHBpositivedirectionReconoise2", "", nphi, 0., 72.);
14171  for (int jeta = 0; jeta < njeta; jeta++) {
14172  // positivedirectionReconoise:
14173  if (jeta - 41 >= 0 && jeta - 41 <= 15) {
14174  // for (int i=0;i<ndepth;i++) {
14175  // depth=2
14176  for (int i = 1; i < 2; i++) {
14177  TH1F *HBpositivedirectionReconoise2 = (TH1F *)h2CeffHBpositivedirectionReconoise2->Clone("twod1");
14178  float ccctest = 0; // to avoid empty massive elements
14179  for (int jphi = 0; jphi < nphi; jphi++) {
14180  double ccc1 = areconoiseHB[i][jeta][jphi];
14181  if (ccc1 != 0.) {
14182  HBpositivedirectionReconoise2->Fill(jphi, ccc1);
14183  ccctest = 1.; //HBpositivedirectionReconoise2->SetBinError(i,0.01);
14184  }
14185  } // for jphi
14186  if (ccctest > 0.) {
14187  //cout<<"555 kcountHBpositivedirectionReconoise2 = "<<kcountHBpositivedirectionReconoise2 <<" jeta-41= "<< jeta-41 <<endl;
14188  c3x5->cd(kcountHBpositivedirectionReconoise2);
14189  HBpositivedirectionReconoise2->SetMarkerStyle(20);
14190  HBpositivedirectionReconoise2->SetMarkerSize(0.4);
14191  HBpositivedirectionReconoise2->GetYaxis()->SetLabelSize(0.04);
14192  HBpositivedirectionReconoise2->SetXTitle("HBpositivedirectionReconoise2 \b");
14193  HBpositivedirectionReconoise2->SetMarkerColor(2);
14194  HBpositivedirectionReconoise2->SetLineColor(0);
14195  gPad->SetGridy();
14196  gPad->SetGridx();
14197  // gPad->SetLogy();
14198  if (kcountHBpositivedirectionReconoise2 == 1)
14199  HBpositivedirectionReconoise2->SetXTitle("R for HB+ jeta = 0; depth = 2 \b");
14200  if (kcountHBpositivedirectionReconoise2 == 2)
14201  HBpositivedirectionReconoise2->SetXTitle("R for HB+ jeta = 1; depth = 2 \b");
14202  if (kcountHBpositivedirectionReconoise2 == 3)
14203  HBpositivedirectionReconoise2->SetXTitle("R for HB+ jeta = 2; depth = 2 \b");
14204  if (kcountHBpositivedirectionReconoise2 == 4)
14205  HBpositivedirectionReconoise2->SetXTitle("R for HB+ jeta = 3; depth = 2 \b");
14206  if (kcountHBpositivedirectionReconoise2 == 5)
14207  HBpositivedirectionReconoise2->SetXTitle("R for HB+ jeta = 4; depth = 2 \b");
14208  if (kcountHBpositivedirectionReconoise2 == 6)
14209  HBpositivedirectionReconoise2->SetXTitle("R for HB+ jeta = 5; depth = 2 \b");
14210  if (kcountHBpositivedirectionReconoise2 == 7)
14211  HBpositivedirectionReconoise2->SetXTitle("R for HB+ jeta = 6; depth = 2 \b");
14212  if (kcountHBpositivedirectionReconoise2 == 8)
14213  HBpositivedirectionReconoise2->SetXTitle("R for HB+ jeta = 7; depth = 2 \b");
14214  if (kcountHBpositivedirectionReconoise2 == 9)
14215  HBpositivedirectionReconoise2->SetXTitle("R for HB+ jeta = 8; depth = 2 \b");
14216  if (kcountHBpositivedirectionReconoise2 == 10)
14217  HBpositivedirectionReconoise2->SetXTitle("R for HB+ jeta = 9; depth = 2 \b");
14218  if (kcountHBpositivedirectionReconoise2 == 11)
14219  HBpositivedirectionReconoise2->SetXTitle("R for HB+ jeta = 10; depth = 2 \b");
14220  if (kcountHBpositivedirectionReconoise2 == 12)
14221  HBpositivedirectionReconoise2->SetXTitle("R for HB+ jeta = 11; depth = 2 \b");
14222  if (kcountHBpositivedirectionReconoise2 == 13)
14223  HBpositivedirectionReconoise2->SetXTitle("R for HB+ jeta = 12; depth = 2 \b");
14224  if (kcountHBpositivedirectionReconoise2 == 14)
14225  HBpositivedirectionReconoise2->SetXTitle("R for HB+ jeta = 13; depth = 2 \b");
14226  if (kcountHBpositivedirectionReconoise2 == 15)
14227  HBpositivedirectionReconoise2->SetXTitle("R for HB+ jeta = 14; depth = 2 \b");
14228  if (kcountHBpositivedirectionReconoise2 == 16)
14229  HBpositivedirectionReconoise2->SetXTitle("R for HB+ jeta = 15; depth = 2 \b");
14230  HBpositivedirectionReconoise2->Draw("Error");
14231  kcountHBpositivedirectionReconoise2++;
14232  if (kcountHBpositivedirectionReconoise2 > 16)
14233  break; // 4x6 = 24
14234  } //ccctest>0
14235 
14236  } // for i
14237  } //if(jeta-41 >= 0)
14238  } //for jeta
14240  c3x5->Update();
14241  c3x5->Print("RreconoisePositiveDirectionhistD1PhiSymmetryDepth2HB.png");
14242  c3x5->Clear();
14243  // clean-up
14244  if (h2CeffHBpositivedirectionReconoise2)
14245  delete h2CeffHBpositivedirectionReconoise2;
14246  //========================================================================================== 6
14247  //======================================================================
14248  //======================================================================1D plot: R vs phi , different eta, depth=3
14249  //cout<<" 1D plot: R vs phi , different eta, depth=3 *****" <<endl;
14250  c3x5->Clear();
14252  c3x5->Divide(4, 4);
14253  c3x5->cd(1);
14254  int kcountHBpositivedirectionReconoise3 = 1;
14255  TH1F *h2CeffHBpositivedirectionReconoise3 = new TH1F("h2CeffHBpositivedirectionReconoise3", "", nphi, 0., 72.);
14256  for (int jeta = 0; jeta < njeta; jeta++) {
14257  // positivedirectionReconoise:
14258  if (jeta - 41 >= 0 && jeta - 41 <= 15) {
14259  // for (int i=0;i<ndepth;i++) {
14260  // depth=3
14261  for (int i = 2; i < 3; i++) {
14262  TH1F *HBpositivedirectionReconoise3 = (TH1F *)h2CeffHBpositivedirectionReconoise3->Clone("twod1");
14263  float ccctest = 0; // to avoid empty massive elements
14264  for (int jphi = 0; jphi < nphi; jphi++) {
14265  double ccc1 = areconoiseHB[i][jeta][jphi];
14266  if (ccc1 != 0.) {
14267  HBpositivedirectionReconoise3->Fill(jphi, ccc1);
14268  ccctest = 1.; //HBpositivedirectionReconoise3->SetBinError(i,0.01);
14269  }
14270  } // for jphi
14271  if (ccctest > 0.) {
14272  //cout<<"666 kcountHBpositivedirectionReconoise3 = "<<kcountHBpositivedirectionReconoise3 <<" jeta-41= "<< jeta-41 <<endl;
14273  c3x5->cd(kcountHBpositivedirectionReconoise3);
14274  HBpositivedirectionReconoise3->SetMarkerStyle(20);
14275  HBpositivedirectionReconoise3->SetMarkerSize(0.4);
14276  HBpositivedirectionReconoise3->GetYaxis()->SetLabelSize(0.04);
14277  HBpositivedirectionReconoise3->SetXTitle("HBpositivedirectionReconoise3 \b");
14278  HBpositivedirectionReconoise3->SetMarkerColor(2);
14279  HBpositivedirectionReconoise3->SetLineColor(0);
14280  gPad->SetGridy();
14281  gPad->SetGridx();
14282  // gPad->SetLogy();
14283  if (kcountHBpositivedirectionReconoise3 == 1)
14284  HBpositivedirectionReconoise3->SetXTitle("R for HB+ jeta = 0; depth = 3 \b");
14285  if (kcountHBpositivedirectionReconoise3 == 2)
14286  HBpositivedirectionReconoise3->SetXTitle("R for HB+ jeta = 1; depth = 3 \b");
14287  if (kcountHBpositivedirectionReconoise3 == 3)
14288  HBpositivedirectionReconoise3->SetXTitle("R for HB+ jeta = 2; depth = 3 \b");
14289  if (kcountHBpositivedirectionReconoise3 == 4)
14290  HBpositivedirectionReconoise3->SetXTitle("R for HB+ jeta = 3; depth = 3 \b");
14291  if (kcountHBpositivedirectionReconoise3 == 5)
14292  HBpositivedirectionReconoise3->SetXTitle("R for HB+ jeta = 4; depth = 3 \b");
14293  if (kcountHBpositivedirectionReconoise3 == 6)
14294  HBpositivedirectionReconoise3->SetXTitle("R for HB+ jeta = 5; depth = 3 \b");
14295  if (kcountHBpositivedirectionReconoise3 == 7)
14296  HBpositivedirectionReconoise3->SetXTitle("R for HB+ jeta = 6; depth = 3 \b");
14297  if (kcountHBpositivedirectionReconoise3 == 8)
14298  HBpositivedirectionReconoise3->SetXTitle("R for HB+ jeta = 7; depth = 3 \b");
14299  if (kcountHBpositivedirectionReconoise3 == 9)
14300  HBpositivedirectionReconoise3->SetXTitle("R for HB+ jeta = 8; depth = 3 \b");
14301  if (kcountHBpositivedirectionReconoise3 == 10)
14302  HBpositivedirectionReconoise3->SetXTitle("R for HB+ jeta = 9; depth = 3 \b");
14303  if (kcountHBpositivedirectionReconoise3 == 11)
14304  HBpositivedirectionReconoise3->SetXTitle("R for HB+ jeta = 0; depth = 3 \b");
14305  if (kcountHBpositivedirectionReconoise3 == 12)
14306  HBpositivedirectionReconoise3->SetXTitle("R for HB+ jeta = 11; depth = 3 \b");
14307  if (kcountHBpositivedirectionReconoise3 == 13)
14308  HBpositivedirectionReconoise3->SetXTitle("R for HB+ jeta = 12; depth = 3 \b");
14309  if (kcountHBpositivedirectionReconoise3 == 14)
14310  HBpositivedirectionReconoise3->SetXTitle("R for HB+ jeta = 13; depth = 3 \b");
14311  if (kcountHBpositivedirectionReconoise3 == 15)
14312  HBpositivedirectionReconoise3->SetXTitle("R for HB+ jeta = 14; depth = 3 \b");
14313  if (kcountHBpositivedirectionReconoise3 == 16)
14314  HBpositivedirectionReconoise3->SetXTitle("R for HB+ jeta = 15; depth = 3 \b");
14315  HBpositivedirectionReconoise3->Draw("Error");
14316  kcountHBpositivedirectionReconoise3++;
14317  if (kcountHBpositivedirectionReconoise3 > 16)
14318  break; // 4x6 = 24
14319  } //ccctest>0
14320 
14321  } // for i
14322  } //if(jeta-41 >= 0)
14323  } //for jeta
14325  c3x5->Update();
14326  c3x5->Print("RreconoisePositiveDirectionhistD1PhiSymmetryDepth3HB.png");
14327  c3x5->Clear();
14328  // clean-up
14329  if (h2CeffHBpositivedirectionReconoise3)
14330  delete h2CeffHBpositivedirectionReconoise3;
14331  //========================================================================================== 7
14332  //======================================================================
14333  //======================================================================1D plot: R vs phi , different eta, depth=4
14334  //cout<<" 1D plot: R vs phi , different eta, depth=4 *****" <<endl;
14335  c3x5->Clear();
14337  c3x5->Divide(4, 4);
14338  c3x5->cd(1);
14339  int kcountHBpositivedirectionReconoise4 = 1;
14340  TH1F *h2CeffHBpositivedirectionReconoise4 = new TH1F("h2CeffHBpositivedirectionReconoise4", "", nphi, 0., 72.);
14341 
14342  for (int jeta = 0; jeta < njeta; jeta++) {
14343  // positivedirectionReconoise:
14344  if (jeta - 41 >= 0 && jeta - 41 <= 15) {
14345  // for (int i=0;i<ndepth;i++) {
14346  // depth=4
14347  for (int i = 3; i < 4; i++) {
14348  TH1F *HBpositivedirectionReconoise4 = (TH1F *)h2CeffHBpositivedirectionReconoise4->Clone("twod1");
14349 
14350  float ccctest = 0; // to avoid empty massive elements
14351  for (int jphi = 0; jphi < nphi; jphi++) {
14352  double ccc1 = areconoiseHB[i][jeta][jphi];
14353  if (ccc1 != 0.) {
14354  HBpositivedirectionReconoise4->Fill(jphi, ccc1);
14355  ccctest = 1.; //HBpositivedirectionReconoise4->SetBinError(i,0.01);
14356  }
14357  } // for jphi
14358  if (ccctest > 0.) {
14359  //cout<<"777 kcountHBpositivedirectionReconoise4 = "<<kcountHBpositivedirectionReconoise4 <<" jeta-41= "<< jeta-41 <<endl;
14360  c3x5->cd(kcountHBpositivedirectionReconoise4);
14361  HBpositivedirectionReconoise4->SetMarkerStyle(20);
14362  HBpositivedirectionReconoise4->SetMarkerSize(0.4);
14363  HBpositivedirectionReconoise4->GetYaxis()->SetLabelSize(0.04);
14364  HBpositivedirectionReconoise4->SetXTitle("HBpositivedirectionReconoise4 \b");
14365  HBpositivedirectionReconoise4->SetMarkerColor(2);
14366  HBpositivedirectionReconoise4->SetLineColor(0);
14367  gPad->SetGridy();
14368  gPad->SetGridx();
14369  // gPad->SetLogy();
14370  if (kcountHBpositivedirectionReconoise4 == 1)
14371  HBpositivedirectionReconoise4->SetXTitle("R for HB+ jeta = 0; depth = 4 \b");
14372  if (kcountHBpositivedirectionReconoise4 == 2)
14373  HBpositivedirectionReconoise4->SetXTitle("R for HB+ jeta = 1; depth = 4 \b");
14374  if (kcountHBpositivedirectionReconoise4 == 3)
14375  HBpositivedirectionReconoise4->SetXTitle("R for HB+ jeta = 2; depth = 4 \b");
14376  if (kcountHBpositivedirectionReconoise4 == 4)
14377  HBpositivedirectionReconoise4->SetXTitle("R for HB+ jeta = 3; depth = 4 \b");
14378  if (kcountHBpositivedirectionReconoise4 == 5)
14379  HBpositivedirectionReconoise4->SetXTitle("R for HB+ jeta = 4; depth = 4 \b");
14380  if (kcountHBpositivedirectionReconoise4 == 6)
14381  HBpositivedirectionReconoise4->SetXTitle("R for HB+ jeta = 5; depth = 4 \b");
14382  if (kcountHBpositivedirectionReconoise4 == 7)
14383  HBpositivedirectionReconoise4->SetXTitle("R for HB+ jeta = 6; depth = 4 \b");
14384  if (kcountHBpositivedirectionReconoise4 == 8)
14385  HBpositivedirectionReconoise4->SetXTitle("R for HB+ jeta = 7; depth = 4 \b");
14386  if (kcountHBpositivedirectionReconoise4 == 9)
14387  HBpositivedirectionReconoise4->SetXTitle("R for HB+ jeta = 8; depth = 4 \b");
14388  if (kcountHBpositivedirectionReconoise4 == 10)
14389  HBpositivedirectionReconoise4->SetXTitle("R for HB+ jeta = 9; depth = 4 \b");
14390  if (kcountHBpositivedirectionReconoise4 == 11)
14391  HBpositivedirectionReconoise4->SetXTitle("R for HB+ jeta = 10; depth = 4 \b");
14392  if (kcountHBpositivedirectionReconoise4 == 12)
14393  HBpositivedirectionReconoise4->SetXTitle("R for HB+ jeta = 11; depth = 4 \b");
14394  if (kcountHBpositivedirectionReconoise4 == 13)
14395  HBpositivedirectionReconoise4->SetXTitle("R for HB+ jeta = 12; depth = 4 \b");
14396  if (kcountHBpositivedirectionReconoise4 == 14)
14397  HBpositivedirectionReconoise4->SetXTitle("R for HB+ jeta = 13; depth = 4 \b");
14398  if (kcountHBpositivedirectionReconoise4 == 15)
14399  HBpositivedirectionReconoise4->SetXTitle("R for HB+ jeta = 14; depth = 4 \b");
14400  if (kcountHBpositivedirectionReconoise4 == 16)
14401  HBpositivedirectionReconoise4->SetXTitle("R for HB+ jeta = 15; depth = 4 \b");
14402  HBpositivedirectionReconoise4->Draw("Error");
14403  kcountHBpositivedirectionReconoise4++;
14404  if (kcountHBpositivedirectionReconoise4 > 16)
14405  break; // 4x6 = 24
14406  } //ccctest>0
14407 
14408  } // for i
14409  } //if(jeta-41 >= 0)
14410  } //for jeta
14412  c3x5->Update();
14413  c3x5->Print("RreconoisePositiveDirectionhistD1PhiSymmetryDepth4HB.png");
14414  c3x5->Clear();
14415  // clean-up
14416  if (h2CeffHBpositivedirectionReconoise4)
14417  delete h2CeffHBpositivedirectionReconoise4;
14418 
14419  //========================================================================================== 1114
14420  //======================================================================
14421  //======================================================================1D plot: R vs phi , different eta, depth=1
14422  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
14423  c3x5->Clear();
14425  c3x5->Divide(4, 4);
14426  c3x5->cd(1);
14427  int kcountHBnegativedirectionReconoise1 = 1;
14428  TH1F *h2CeffHBnegativedirectionReconoise1 = new TH1F("h2CeffHBnegativedirectionReconoise1", "", nphi, 0., 72.);
14429  for (int jeta = 0; jeta < njeta; jeta++) {
14430  // negativedirectionReconoise:
14431  if (jeta - 41 >= -16 && jeta - 41 <= -1) {
14432  // for (int i=0;i<ndepth;i++) {
14433  // depth=1
14434  for (int i = 0; i < 1; i++) {
14435  TH1F *HBnegativedirectionReconoise1 = (TH1F *)h2CeffHBnegativedirectionReconoise1->Clone("twod1");
14436  float ccctest = 0; // to avoid empty massive elements
14437  for (int jphi = 0; jphi < nphi; jphi++) {
14438  double ccc1 = areconoiseHB[i][jeta][jphi];
14439  if (ccc1 != 0.) {
14440  HBnegativedirectionReconoise1->Fill(jphi, ccc1);
14441  ccctest = 1.; //HBnegativedirectionReconoise1->SetBinError(i,0.01);
14442  }
14443  } // for jphi
14444  if (ccctest > 0.) {
14445  // cout<<"444 kcountHBnegativedirectionReconoise1 = "<<kcountHBnegativedirectionReconoise1 <<" jeta-41= "<< jeta-41 <<endl;
14446  c3x5->cd(kcountHBnegativedirectionReconoise1);
14447  HBnegativedirectionReconoise1->SetMarkerStyle(20);
14448  HBnegativedirectionReconoise1->SetMarkerSize(0.4);
14449  HBnegativedirectionReconoise1->GetYaxis()->SetLabelSize(0.04);
14450  HBnegativedirectionReconoise1->SetXTitle("HBnegativedirectionReconoise1 \b");
14451  HBnegativedirectionReconoise1->SetMarkerColor(2);
14452  HBnegativedirectionReconoise1->SetLineColor(0);
14453  gPad->SetGridy();
14454  gPad->SetGridx();
14455  // gPad->SetLogy();
14456  if (kcountHBnegativedirectionReconoise1 == 1)
14457  HBnegativedirectionReconoise1->SetXTitle("R for HB- jeta = -16; depth = 1 \b");
14458  if (kcountHBnegativedirectionReconoise1 == 2)
14459  HBnegativedirectionReconoise1->SetXTitle("R for HB- jeta = -15; depth = 1 \b");
14460  if (kcountHBnegativedirectionReconoise1 == 3)
14461  HBnegativedirectionReconoise1->SetXTitle("R for HB- jeta = -14; depth = 1 \b");
14462  if (kcountHBnegativedirectionReconoise1 == 4)
14463  HBnegativedirectionReconoise1->SetXTitle("R for HB- jeta = -13; depth = 1 \b");
14464  if (kcountHBnegativedirectionReconoise1 == 5)
14465  HBnegativedirectionReconoise1->SetXTitle("R for HB- jeta = -12; depth = 1 \b");
14466  if (kcountHBnegativedirectionReconoise1 == 6)
14467  HBnegativedirectionReconoise1->SetXTitle("R for HB- jeta = -11; depth = 1 \b");
14468  if (kcountHBnegativedirectionReconoise1 == 7)
14469  HBnegativedirectionReconoise1->SetXTitle("R for HB- jeta = -10; depth = 1 \b");
14470  if (kcountHBnegativedirectionReconoise1 == 8)
14471  HBnegativedirectionReconoise1->SetXTitle("R for HB- jeta = -9; depth = 1 \b");
14472  if (kcountHBnegativedirectionReconoise1 == 9)
14473  HBnegativedirectionReconoise1->SetXTitle("R for HB- jeta = -8; depth = 1 \b");
14474  if (kcountHBnegativedirectionReconoise1 == 10)
14475  HBnegativedirectionReconoise1->SetXTitle("R for HB- jeta = -7; depth = 1 \b");
14476  if (kcountHBnegativedirectionReconoise1 == 11)
14477  HBnegativedirectionReconoise1->SetXTitle("R for HB- jeta = -6; depth = 1 \b");
14478  if (kcountHBnegativedirectionReconoise1 == 12)
14479  HBnegativedirectionReconoise1->SetXTitle("R for HB- jeta = -5; depth = 1 \b");
14480  if (kcountHBnegativedirectionReconoise1 == 13)
14481  HBnegativedirectionReconoise1->SetXTitle("R for HB- jeta = -4; depth = 1 \b");
14482  if (kcountHBnegativedirectionReconoise1 == 14)
14483  HBnegativedirectionReconoise1->SetXTitle("R for HB- jeta = -3; depth = 1 \b");
14484  if (kcountHBnegativedirectionReconoise1 == 15)
14485  HBnegativedirectionReconoise1->SetXTitle("R for HB- jeta = -2; depth = 1 \b");
14486  if (kcountHBnegativedirectionReconoise1 == 16)
14487  HBnegativedirectionReconoise1->SetXTitle("R for HB- jeta = -1; depth = 1 \b");
14488  HBnegativedirectionReconoise1->Draw("Error");
14489  kcountHBnegativedirectionReconoise1++;
14490  if (kcountHBnegativedirectionReconoise1 > 16)
14491  break; //
14492  } //ccctest>0
14493 
14494  } // for i
14495  } //if(jeta-41 < 0 )
14496  } //for jeta
14498  c3x5->Update();
14499  c3x5->Print("RreconoiseNegativeDirectionhistD1PhiSymmetryDepth1HB.png");
14500  c3x5->Clear();
14501  // clean-up
14502  if (h2CeffHBnegativedirectionReconoise1)
14503  delete h2CeffHBnegativedirectionReconoise1;
14504 
14505  //========================================================================================== 1115
14506  //======================================================================
14507  //======================================================================1D plot: R vs phi , different eta, depth=2
14508  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
14509  c3x5->Clear();
14511  c3x5->Divide(4, 4);
14512  c3x5->cd(1);
14513  int kcountHBnegativedirectionReconoise2 = 1;
14514  TH1F *h2CeffHBnegativedirectionReconoise2 = new TH1F("h2CeffHBnegativedirectionReconoise2", "", nphi, 0., 72.);
14515  for (int jeta = 0; jeta < njeta; jeta++) {
14516  // negativedirectionReconoise:
14517  if (jeta - 41 >= -16 && jeta - 41 <= -1) {
14518  // for (int i=0;i<ndepth;i++) {
14519  // depth=2
14520  for (int i = 1; i < 2; i++) {
14521  TH1F *HBnegativedirectionReconoise2 = (TH1F *)h2CeffHBnegativedirectionReconoise2->Clone("twod1");
14522  float ccctest = 0; // to avoid empty massive elements
14523  for (int jphi = 0; jphi < nphi; jphi++) {
14524  double ccc1 = areconoiseHB[i][jeta][jphi];
14525  if (ccc1 != 0.) {
14526  HBnegativedirectionReconoise2->Fill(jphi, ccc1);
14527  ccctest = 1.; //HBnegativedirectionReconoise2->SetBinError(i,0.01);
14528  }
14529  } // for jphi
14530  if (ccctest > 0.) {
14531  //cout<<"555 kcountHBnegativedirectionReconoise2 = "<<kcountHBnegativedirectionReconoise2 <<" jeta-41= "<< jeta-41 <<endl;
14532  c3x5->cd(kcountHBnegativedirectionReconoise2);
14533  HBnegativedirectionReconoise2->SetMarkerStyle(20);
14534  HBnegativedirectionReconoise2->SetMarkerSize(0.4);
14535  HBnegativedirectionReconoise2->GetYaxis()->SetLabelSize(0.04);
14536  HBnegativedirectionReconoise2->SetXTitle("HBnegativedirectionReconoise2 \b");
14537  HBnegativedirectionReconoise2->SetMarkerColor(2);
14538  HBnegativedirectionReconoise2->SetLineColor(0);
14539  gPad->SetGridy();
14540  gPad->SetGridx();
14541  // gPad->SetLogy();
14542  if (kcountHBnegativedirectionReconoise2 == 1)
14543  HBnegativedirectionReconoise2->SetXTitle("R for HB- jeta = -16; depth = 2 \b");
14544  if (kcountHBnegativedirectionReconoise2 == 2)
14545  HBnegativedirectionReconoise2->SetXTitle("R for HB- jeta = -15; depth = 2 \b");
14546  if (kcountHBnegativedirectionReconoise2 == 3)
14547  HBnegativedirectionReconoise2->SetXTitle("R for HB- jeta = -14; depth = 2 \b");
14548  if (kcountHBnegativedirectionReconoise2 == 4)
14549  HBnegativedirectionReconoise2->SetXTitle("R for HB- jeta = -13; depth = 2 \b");
14550  if (kcountHBnegativedirectionReconoise2 == 5)
14551  HBnegativedirectionReconoise2->SetXTitle("R for HB- jeta = -12; depth = 2 \b");
14552  if (kcountHBnegativedirectionReconoise2 == 6)
14553  HBnegativedirectionReconoise2->SetXTitle("R for HB- jeta = -11; depth = 2 \b");
14554  if (kcountHBnegativedirectionReconoise2 == 7)
14555  HBnegativedirectionReconoise2->SetXTitle("R for HB- jeta = -10; depth = 2 \b");
14556  if (kcountHBnegativedirectionReconoise2 == 8)
14557  HBnegativedirectionReconoise2->SetXTitle("R for HB- jeta = -9; depth = 2 \b");
14558  if (kcountHBnegativedirectionReconoise2 == 9)
14559  HBnegativedirectionReconoise2->SetXTitle("R for HB- jeta = -8; depth = 2 \b");
14560  if (kcountHBnegativedirectionReconoise2 == 10)
14561  HBnegativedirectionReconoise2->SetXTitle("R for HB- jeta = -7; depth = 2 \b");
14562  if (kcountHBnegativedirectionReconoise2 == 11)
14563  HBnegativedirectionReconoise2->SetXTitle("R for HB- jeta = -6; depth = 2 \b");
14564  if (kcountHBnegativedirectionReconoise2 == 12)
14565  HBnegativedirectionReconoise2->SetXTitle("R for HB- jeta = -5; depth = 2 \b");
14566  if (kcountHBnegativedirectionReconoise2 == 13)
14567  HBnegativedirectionReconoise2->SetXTitle("R for HB- jeta = -4; depth = 2 \b");
14568  if (kcountHBnegativedirectionReconoise2 == 14)
14569  HBnegativedirectionReconoise2->SetXTitle("R for HB- jeta = -3; depth = 2 \b");
14570  if (kcountHBnegativedirectionReconoise2 == 15)
14571  HBnegativedirectionReconoise2->SetXTitle("R for HB- jeta = -2; depth = 2 \b");
14572  if (kcountHBnegativedirectionReconoise2 == 16)
14573  HBnegativedirectionReconoise2->SetXTitle("R for HB- jeta = -1; depth = 2 \b");
14574  HBnegativedirectionReconoise2->Draw("Error");
14575  kcountHBnegativedirectionReconoise2++;
14576  if (kcountHBnegativedirectionReconoise2 > 16)
14577  break; // 4x6 = 24
14578  } //ccctest>0
14579 
14580  } // for i
14581  } //if(jeta-41 < 0 )
14582  } //for jeta
14584  c3x5->Update();
14585  c3x5->Print("RreconoiseNegativeDirectionhistD1PhiSymmetryDepth2HB.png");
14586  c3x5->Clear();
14587  // clean-up
14588  if (h2CeffHBnegativedirectionReconoise2)
14589  delete h2CeffHBnegativedirectionReconoise2;
14590  //========================================================================================== 1116
14591  //======================================================================
14592  //======================================================================1D plot: R vs phi , different eta, depth=3
14593  //cout<<" 1D plot: R vs phi , different eta, depth=3 *****" <<endl;
14594  c3x5->Clear();
14596  c3x5->Divide(4, 4);
14597  c3x5->cd(1);
14598  int kcountHBnegativedirectionReconoise3 = 1;
14599  TH1F *h2CeffHBnegativedirectionReconoise3 = new TH1F("h2CeffHBnegativedirectionReconoise3", "", nphi, 0., 72.);
14600  for (int jeta = 0; jeta < njeta; jeta++) {
14601  // negativedirectionReconoise:
14602  if (jeta - 41 >= -16 && jeta - 41 <= -1) {
14603  // for (int i=0;i<ndepth;i++) {
14604  // depth=3
14605  for (int i = 2; i < 3; i++) {
14606  TH1F *HBnegativedirectionReconoise3 = (TH1F *)h2CeffHBnegativedirectionReconoise3->Clone("twod1");
14607  float ccctest = 0; // to avoid empty massive elements
14608  for (int jphi = 0; jphi < nphi; jphi++) {
14609  double ccc1 = areconoiseHB[i][jeta][jphi];
14610  if (ccc1 != 0.) {
14611  HBnegativedirectionReconoise3->Fill(jphi, ccc1);
14612  ccctest = 1.; //HBnegativedirectionReconoise3->SetBinError(i,0.01);
14613  }
14614  } // for jphi
14615  if (ccctest > 0.) {
14616  //cout<<"666 kcountHBnegativedirectionReconoise3 = "<<kcountHBnegativedirectionReconoise3 <<" jeta-41= "<< jeta-41 <<endl;
14617  c3x5->cd(kcountHBnegativedirectionReconoise3);
14618  HBnegativedirectionReconoise3->SetMarkerStyle(20);
14619  HBnegativedirectionReconoise3->SetMarkerSize(0.4);
14620  HBnegativedirectionReconoise3->GetYaxis()->SetLabelSize(0.04);
14621  HBnegativedirectionReconoise3->SetXTitle("HBnegativedirectionReconoise3 \b");
14622  HBnegativedirectionReconoise3->SetMarkerColor(2);
14623  HBnegativedirectionReconoise3->SetLineColor(0);
14624  gPad->SetGridy();
14625  gPad->SetGridx();
14626  // gPad->SetLogy();
14627  if (kcountHBnegativedirectionReconoise3 == 1)
14628  HBnegativedirectionReconoise3->SetXTitle("R for HB- jeta = -16; depth = 3 \b");
14629  if (kcountHBnegativedirectionReconoise3 == 2)
14630  HBnegativedirectionReconoise3->SetXTitle("R for HB- jeta = -15; depth = 3 \b");
14631  if (kcountHBnegativedirectionReconoise3 == 3)
14632  HBnegativedirectionReconoise3->SetXTitle("R for HB- jeta = -14; depth = 3 \b");
14633  if (kcountHBnegativedirectionReconoise3 == 4)
14634  HBnegativedirectionReconoise3->SetXTitle("R for HB- jeta = -13; depth = 3 \b");
14635  if (kcountHBnegativedirectionReconoise3 == 5)
14636  HBnegativedirectionReconoise3->SetXTitle("R for HB- jeta = -12; depth = 3 \b");
14637  if (kcountHBnegativedirectionReconoise3 == 6)
14638  HBnegativedirectionReconoise3->SetXTitle("R for HB- jeta = -11; depth = 3 \b");
14639  if (kcountHBnegativedirectionReconoise3 == 7)
14640  HBnegativedirectionReconoise3->SetXTitle("R for HB- jeta = -10; depth = 3 \b");
14641  if (kcountHBnegativedirectionReconoise3 == 8)
14642  HBnegativedirectionReconoise3->SetXTitle("R for HB- jeta = -9; depth = 3 \b");
14643  if (kcountHBnegativedirectionReconoise3 == 9)
14644  HBnegativedirectionReconoise3->SetXTitle("R for HB- jeta = -8; depth = 3 \b");
14645  if (kcountHBnegativedirectionReconoise3 == 10)
14646  HBnegativedirectionReconoise3->SetXTitle("R for HB- jeta = -7; depth = 3 \b");
14647  if (kcountHBnegativedirectionReconoise3 == 11)
14648  HBnegativedirectionReconoise3->SetXTitle("R for HB- jeta = -6; depth = 3 \b");
14649  if (kcountHBnegativedirectionReconoise3 == 12)
14650  HBnegativedirectionReconoise3->SetXTitle("R for HB- jeta = -5; depth = 3 \b");
14651  if (kcountHBnegativedirectionReconoise3 == 13)
14652  HBnegativedirectionReconoise3->SetXTitle("R for HB- jeta = -4; depth = 3 \b");
14653  if (kcountHBnegativedirectionReconoise3 == 14)
14654  HBnegativedirectionReconoise3->SetXTitle("R for HB- jeta = -3; depth = 3 \b");
14655  if (kcountHBnegativedirectionReconoise3 == 15)
14656  HBnegativedirectionReconoise3->SetXTitle("R for HB- jeta = -2; depth = 3 \b");
14657  if (kcountHBnegativedirectionReconoise3 == 16)
14658  HBnegativedirectionReconoise3->SetXTitle("R for HB- jeta = -1; depth = 3 \b");
14659 
14660  HBnegativedirectionReconoise3->Draw("Error");
14661  kcountHBnegativedirectionReconoise3++;
14662  if (kcountHBnegativedirectionReconoise3 > 16)
14663  break; // 4x6 = 24
14664  } //ccctest>0
14665 
14666  } // for i
14667  } //if(jeta-41 < 0 )
14668  } //for jeta
14670  c3x5->Update();
14671  c3x5->Print("RreconoiseNegativeDirectionhistD1PhiSymmetryDepth3HB.png");
14672  c3x5->Clear();
14673  // clean-up
14674  if (h2CeffHBnegativedirectionReconoise3)
14675  delete h2CeffHBnegativedirectionReconoise3;
14676  //========================================================================================== 1117
14677  //======================================================================
14678  //======================================================================1D plot: R vs phi , different eta, depth=4
14679  //cout<<" 1D plot: R vs phi , different eta, depth=4 *****" <<endl;
14680  c3x5->Clear();
14682  c3x5->Divide(4, 4);
14683  c3x5->cd(1);
14684  int kcountHBnegativedirectionReconoise4 = 1;
14685  TH1F *h2CeffHBnegativedirectionReconoise4 = new TH1F("h2CeffHBnegativedirectionReconoise4", "", nphi, 0., 72.);
14686 
14687  for (int jeta = 0; jeta < njeta; jeta++) {
14688  // negativedirectionReconoise:
14689  if (jeta - 41 >= -16 && jeta - 41 <= -1) {
14690  // for (int i=0;i<ndepth;i++) {
14691  // depth=4
14692  for (int i = 3; i < 4; i++) {
14693  TH1F *HBnegativedirectionReconoise4 = (TH1F *)h2CeffHBnegativedirectionReconoise4->Clone("twod1");
14694 
14695  float ccctest = 0; // to avoid empty massive elements
14696  for (int jphi = 0; jphi < nphi; jphi++) {
14697  double ccc1 = areconoiseHB[i][jeta][jphi];
14698  if (ccc1 != 0.) {
14699  HBnegativedirectionReconoise4->Fill(jphi, ccc1);
14700  ccctest = 1.; //HBnegativedirectionReconoise4->SetBinError(i,0.01);
14701  }
14702  } // for jphi
14703  if (ccctest > 0.) {
14704  //cout<<"777 kcountHBnegativedirectionReconoise4 = "<<kcountHBnegativedirectionReconoise4 <<" jeta-41= "<< jeta-41 <<endl;
14705  c3x5->cd(kcountHBnegativedirectionReconoise4);
14706  HBnegativedirectionReconoise4->SetMarkerStyle(20);
14707  HBnegativedirectionReconoise4->SetMarkerSize(0.4);
14708  HBnegativedirectionReconoise4->GetYaxis()->SetLabelSize(0.04);
14709  HBnegativedirectionReconoise4->SetXTitle("HBnegativedirectionReconoise4 \b");
14710  HBnegativedirectionReconoise4->SetMarkerColor(2);
14711  HBnegativedirectionReconoise4->SetLineColor(0);
14712  gPad->SetGridy();
14713  gPad->SetGridx();
14714  // gPad->SetLogy();
14715  if (kcountHBnegativedirectionReconoise4 == 1)
14716  HBnegativedirectionReconoise4->SetXTitle("R for HB- jeta = -16; depth = 4 \b");
14717  if (kcountHBnegativedirectionReconoise4 == 2)
14718  HBnegativedirectionReconoise4->SetXTitle("R for HB- jeta = -15; depth = 4 \b");
14719  if (kcountHBnegativedirectionReconoise4 == 3)
14720  HBnegativedirectionReconoise4->SetXTitle("R for HB- jeta = -14; depth = 4 \b");
14721  if (kcountHBnegativedirectionReconoise4 == 4)
14722  HBnegativedirectionReconoise4->SetXTitle("R for HB- jeta = -13; depth = 4 \b");
14723  if (kcountHBnegativedirectionReconoise4 == 5)
14724  HBnegativedirectionReconoise4->SetXTitle("R for HB- jeta = -12; depth = 4 \b");
14725  if (kcountHBnegativedirectionReconoise4 == 6)
14726  HBnegativedirectionReconoise4->SetXTitle("R for HB- jeta = -11; depth = 4 \b");
14727  if (kcountHBnegativedirectionReconoise4 == 7)
14728  HBnegativedirectionReconoise4->SetXTitle("R for HB- jeta = -10; depth = 4 \b");
14729  if (kcountHBnegativedirectionReconoise4 == 8)
14730  HBnegativedirectionReconoise4->SetXTitle("R for HB- jeta = -9; depth = 4 \b");
14731  if (kcountHBnegativedirectionReconoise4 == 9)
14732  HBnegativedirectionReconoise4->SetXTitle("R for HB- jeta = -8; depth = 4 \b");
14733  if (kcountHBnegativedirectionReconoise4 == 10)
14734  HBnegativedirectionReconoise4->SetXTitle("R for HB- jeta = -7; depth = 4 \b");
14735  if (kcountHBnegativedirectionReconoise4 == 11)
14736  HBnegativedirectionReconoise4->SetXTitle("R for HB- jeta = -6; depth = 4 \b");
14737  if (kcountHBnegativedirectionReconoise4 == 12)
14738  HBnegativedirectionReconoise4->SetXTitle("R for HB- jeta = -5; depth = 4 \b");
14739  if (kcountHBnegativedirectionReconoise4 == 13)
14740  HBnegativedirectionReconoise4->SetXTitle("R for HB- jeta = -4; depth = 4 \b");
14741  if (kcountHBnegativedirectionReconoise4 == 14)
14742  HBnegativedirectionReconoise4->SetXTitle("R for HB- jeta = -3; depth = 4 \b");
14743  if (kcountHBnegativedirectionReconoise4 == 15)
14744  HBnegativedirectionReconoise4->SetXTitle("R for HB- jeta = -2; depth = 4 \b");
14745  if (kcountHBnegativedirectionReconoise4 == 16)
14746  HBnegativedirectionReconoise4->SetXTitle("R for HB- jeta = -1; depth = 4 \b");
14747  HBnegativedirectionReconoise4->Draw("Error");
14748  kcountHBnegativedirectionReconoise4++;
14749  if (kcountHBnegativedirectionReconoise4 > 16)
14750  break; // 4x6 = 24
14751  } //ccctest>0
14752 
14753  } // for i
14754  } //if(jeta-41 < 0 )
14755  } //for jeta
14757  c3x5->Update();
14758  c3x5->Print("RreconoiseNegativeDirectionhistD1PhiSymmetryDepth4HB.png");
14759  c3x5->Clear();
14760  // clean-up
14761  if (h2CeffHBnegativedirectionReconoise4)
14762  delete h2CeffHBnegativedirectionReconoise4;
14763 
14764  //======================================================================================================================
14765  // DIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIF: Reconoise HE
14766  //======================================================================================================================
14767  //======================================================================
14768  //cout<<" R2D-eta/phi-plot: DIF, averaged over depthfs *****" <<endl;
14769  c2x1->Clear();
14771  c2x1->Divide(2, 1);
14772  c2x1->cd(1);
14773  TH2F *GefzDIFreconoiseHB42D = new TH2F("GefzDIFreconoiseHB42D", "", neta, -41., 41., nphi, 0., 72.);
14774  TH2F *GefzDIFreconoiseHB42D0 = new TH2F("GefzDIFreconoiseHB42D0", "", neta, -41., 41., nphi, 0., 72.);
14775  TH2F *GefzDIFreconoiseHB42DF = (TH2F *)GefzDIFreconoiseHB42D0->Clone("GefzDIFreconoiseHB42DF");
14776  for (int i = 0; i < ndepth; i++) {
14777  for (int jeta = 0; jeta < neta; jeta++) {
14778  if ((jeta - 41 >= -16 && jeta - 41 <= -1) || (jeta - 41 >= 0 && jeta - 41 <= 15)) {
14779  for (int jphi = 0; jphi < nphi; jphi++) {
14780  double ccc1 = breconoiseHB[i][jeta][jphi];
14781  int k2plot = jeta - 41;
14782  int kkk = k2plot; //if(k2plot >0 ) kkk=k2plot+1; //-41 +41 !=0
14783  if (ccc1 != 0.) {
14784  GefzDIFreconoiseHB42D->Fill(kkk, jphi, ccc1);
14785  GefzDIFreconoiseHB42D0->Fill(kkk, jphi, 1.);
14786  }
14787  }
14788  }
14789  }
14790  }
14791  GefzDIFreconoiseHB42DF->Divide(GefzDIFreconoiseHB42D, GefzDIFreconoiseHB42D0, 1, 1, "B"); // average A
14792  gPad->SetGridy();
14793  gPad->SetGridx(); // gPad->SetLogz();
14794  GefzDIFreconoiseHB42DF->SetXTitle("<DIF>_depth #eta \b");
14795  GefzDIFreconoiseHB42DF->SetYTitle(" #phi \b");
14796  GefzDIFreconoiseHB42DF->Draw("COLZ");
14797 
14798  // c2x1->cd(2);
14799  // TH1F *energyhitNoise_HB= (TH1F*)dir->FindObjectAny("h_energyhitNoise_HB");
14800  // energyhitNoise_HB ->SetMarkerStyle(20);energyhitNoise_HB ->SetMarkerSize(0.4);energyhitNoise_HB ->GetYaxis()->SetLabelSize(0.04);energyhitNoise_HB ->SetXTitle("energyhitNoise_HB \b");energyhitNoise_HB ->SetMarkerColor(2);energyhitNoise_HB ->SetLineColor(0);gPad->SetGridy();gPad->SetGridx();energyhitNoise_HB ->Draw("Error");
14801 
14803  c2x1->Update();
14804  c2x1->Print("DIFreconoiseGeneralD2PhiSymmetryHB.png");
14805  c2x1->Clear();
14806  // clean-up
14807  if (GefzDIFreconoiseHB42D)
14808  delete GefzDIFreconoiseHB42D;
14809  if (GefzDIFreconoiseHB42D0)
14810  delete GefzDIFreconoiseHB42D0;
14811  if (GefzDIFreconoiseHB42DF)
14812  delete GefzDIFreconoiseHB42DF;
14813  //====================================================================== 1D plot: DIF vs phi , averaged over depthfs & eta
14814  //======================================================================
14815  //cout<<" 1D plot: DIF vs phi , averaged over depthfs & eta *****" <<endl;
14816  c1x1->Clear();
14818  c1x1->Divide(1, 1);
14819  c1x1->cd(1);
14820  TH1F *GefzDIFreconoiseHB41D = new TH1F("GefzDIFreconoiseHB41D", "", nphi, 0., 72.);
14821  TH1F *GefzDIFreconoiseHB41D0 = new TH1F("GefzDIFreconoiseHB41D0", "", nphi, 0., 72.);
14822  TH1F *GefzDIFreconoiseHB41DF = (TH1F *)GefzDIFreconoiseHB41D0->Clone("GefzDIFreconoiseHB41DF");
14823  for (int jphi = 0; jphi < nphi; jphi++) {
14824  for (int jeta = 0; jeta < neta; jeta++) {
14825  if ((jeta - 41 >= -16 && jeta - 41 <= -1) || (jeta - 41 >= 0 && jeta - 41 <= 15)) {
14826  for (int i = 0; i < ndepth; i++) {
14827  double ccc1 = breconoiseHB[i][jeta][jphi];
14828  if (ccc1 != 0.) {
14829  GefzDIFreconoiseHB41D->Fill(jphi, ccc1);
14830  GefzDIFreconoiseHB41D0->Fill(jphi, 1.);
14831  }
14832  }
14833  }
14834  }
14835  }
14836  GefzDIFreconoiseHB41DF->Divide(
14837  GefzDIFreconoiseHB41D, GefzDIFreconoiseHB41D0, 1, 1, "B"); // DIF averaged over depthfs & eta
14838  GefzDIFreconoiseHB41D0->Sumw2();
14839  // for (int jphi=1;jphi<73;jphi++) {GefzDIFreconoiseHB41DF->SetBinError(jphi,0.01);}
14840  gPad->SetGridy();
14841  gPad->SetGridx(); // gPad->SetLogz();
14842  GefzDIFreconoiseHB41DF->SetMarkerStyle(20);
14843  GefzDIFreconoiseHB41DF->SetMarkerSize(1.4);
14844  GefzDIFreconoiseHB41DF->GetZaxis()->SetLabelSize(0.08);
14845  GefzDIFreconoiseHB41DF->SetXTitle("#phi \b");
14846  GefzDIFreconoiseHB41DF->SetYTitle(" <DIF> \b");
14847  GefzDIFreconoiseHB41DF->SetZTitle("<DIF>_PHI - AllDepthfs \b");
14848  GefzDIFreconoiseHB41DF->SetMarkerColor(4);
14849  GefzDIFreconoiseHB41DF->SetLineColor(
14850  4); //GefzDIFreconoiseHB41DF->SetMinimum(0.8); // GefzDIFreconoiseHB41DF->SetMaximum(1.000);
14851  GefzDIFreconoiseHB41DF->Draw("Error");
14853  c1x1->Update();
14854  c1x1->Print("DIFreconoiseGeneralD1PhiSymmetryHB.png");
14855  c1x1->Clear();
14856  // clean-up
14857  if (GefzDIFreconoiseHB41D)
14858  delete GefzDIFreconoiseHB41D;
14859  if (GefzDIFreconoiseHB41D0)
14860  delete GefzDIFreconoiseHB41D0;
14861  if (GefzDIFreconoiseHB41DF)
14862  delete GefzDIFreconoiseHB41DF;
14863  //========================================================================================== 4
14864  //======================================================================
14865  //======================================================================1D plot: DIF vs phi , different eta, depth=1
14866  //cout<<" 1D plot: DIF vs phi , different eta, depth=1 *****" <<endl;
14867  c3x5->Clear();
14869  c3x5->Divide(4, 4);
14870  c3x5->cd(1);
14871  int kcountHBpositivedirectionReconoiseDIF1 = 1;
14872  TH1F *h2CeffHBpositivedirectionReconoiseDIF1 = new TH1F("h2CeffHBpositivedirectionReconoiseDIF1", "", nphi, 0., 72.);
14873  for (int jeta = 0; jeta < njeta; jeta++) {
14874  // positivedirectionReconoiseDIF:
14875  if (jeta - 41 >= 0 && jeta - 41 <= 15) {
14876  // for (int i=0;i<ndepth;i++) {
14877  // depth=1
14878  for (int i = 0; i < 1; i++) {
14879  TH1F *HBpositivedirectionReconoiseDIF1 = (TH1F *)h2CeffHBpositivedirectionReconoiseDIF1->Clone("twod1");
14880  float ccctest = 0; // to avoid empty massive elements
14881  for (int jphi = 0; jphi < nphi; jphi++) {
14882  double ccc1 = breconoiseHB[i][jeta][jphi];
14883  if (ccc1 != 0.) {
14884  HBpositivedirectionReconoiseDIF1->Fill(jphi, ccc1);
14885  ccctest = 1.; //HBpositivedirectionReconoiseDIF1->SetBinError(i,0.01);
14886  }
14887  } // for jphi
14888  if (ccctest > 0.) {
14889  // cout<<"444 kcountHBpositivedirectionReconoiseDIF1 = "<<kcountHBpositivedirectionReconoiseDIF1 <<" jeta-41= "<< jeta-41 <<endl;
14890  c3x5->cd(kcountHBpositivedirectionReconoiseDIF1);
14891  HBpositivedirectionReconoiseDIF1->SetMarkerStyle(20);
14892  HBpositivedirectionReconoiseDIF1->SetMarkerSize(0.4);
14893  HBpositivedirectionReconoiseDIF1->GetYaxis()->SetLabelSize(0.04);
14894  HBpositivedirectionReconoiseDIF1->SetXTitle("HBpositivedirectionReconoiseDIF1 \b");
14895  HBpositivedirectionReconoiseDIF1->SetMarkerColor(2);
14896  HBpositivedirectionReconoiseDIF1->SetLineColor(0);
14897  gPad->SetGridy();
14898  gPad->SetGridx();
14899  // gPad->SetLogy();
14900  if (kcountHBpositivedirectionReconoiseDIF1 == 1)
14901  HBpositivedirectionReconoiseDIF1->SetXTitle("DIF for HB+ jeta = 0; depth = 1 \b");
14902  if (kcountHBpositivedirectionReconoiseDIF1 == 2)
14903  HBpositivedirectionReconoiseDIF1->SetXTitle("DIF for HB+ jeta = 1; depth = 1 \b");
14904  if (kcountHBpositivedirectionReconoiseDIF1 == 3)
14905  HBpositivedirectionReconoiseDIF1->SetXTitle("DIF for HB+ jeta = 2; depth = 1 \b");
14906  if (kcountHBpositivedirectionReconoiseDIF1 == 4)
14907  HBpositivedirectionReconoiseDIF1->SetXTitle("DIF for HB+ jeta = 3; depth = 1 \b");
14908  if (kcountHBpositivedirectionReconoiseDIF1 == 5)
14909  HBpositivedirectionReconoiseDIF1->SetXTitle("DIF for HB+ jeta = 4; depth = 1 \b");
14910  if (kcountHBpositivedirectionReconoiseDIF1 == 6)
14911  HBpositivedirectionReconoiseDIF1->SetXTitle("DIF for HB+ jeta = 5; depth = 1 \b");
14912  if (kcountHBpositivedirectionReconoiseDIF1 == 7)
14913  HBpositivedirectionReconoiseDIF1->SetXTitle("DIF for HB+ jeta = 6; depth = 1 \b");
14914  if (kcountHBpositivedirectionReconoiseDIF1 == 8)
14915  HBpositivedirectionReconoiseDIF1->SetXTitle("DIF for HB+ jeta = 7; depth = 1 \b");
14916  if (kcountHBpositivedirectionReconoiseDIF1 == 9)
14917  HBpositivedirectionReconoiseDIF1->SetXTitle("DIF for HB+ jeta = 8; depth = 1 \b");
14918  if (kcountHBpositivedirectionReconoiseDIF1 == 10)
14919  HBpositivedirectionReconoiseDIF1->SetXTitle("DIF for HB+ jeta = 9; depth = 1 \b");
14920  if (kcountHBpositivedirectionReconoiseDIF1 == 11)
14921  HBpositivedirectionReconoiseDIF1->SetXTitle("DIF for HB+ jeta = 10; depth = 1 \b");
14922  if (kcountHBpositivedirectionReconoiseDIF1 == 12)
14923  HBpositivedirectionReconoiseDIF1->SetXTitle("DIF for HB+ jeta = 11; depth = 1 \b");
14924  if (kcountHBpositivedirectionReconoiseDIF1 == 13)
14925  HBpositivedirectionReconoiseDIF1->SetXTitle("DIF for HB+ jeta = 12; depth = 1 \b");
14926  if (kcountHBpositivedirectionReconoiseDIF1 == 14)
14927  HBpositivedirectionReconoiseDIF1->SetXTitle("DIF for HB+ jeta = 13; depth = 1 \b");
14928  if (kcountHBpositivedirectionReconoiseDIF1 == 15)
14929  HBpositivedirectionReconoiseDIF1->SetXTitle("DIF for HB+ jeta = 14; depth = 1 \b");
14930  if (kcountHBpositivedirectionReconoiseDIF1 == 16)
14931  HBpositivedirectionReconoiseDIF1->SetXTitle("DIF for HB+ jeta = 15; depth = 1 \b");
14932  HBpositivedirectionReconoiseDIF1->Draw("Error");
14933  kcountHBpositivedirectionReconoiseDIF1++;
14934  if (kcountHBpositivedirectionReconoiseDIF1 > 16)
14935  break; //
14936  } //ccctest>0
14937 
14938  } // for i
14939  } //if(jeta-41 >= 0)
14940  } //for jeta
14942  c3x5->Update();
14943  c3x5->Print("DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth1HB.png");
14944  c3x5->Clear();
14945  // clean-up
14946  if (h2CeffHBpositivedirectionReconoiseDIF1)
14947  delete h2CeffHBpositivedirectionReconoiseDIF1;
14948 
14949  //========================================================================================== 5
14950  //======================================================================
14951  //======================================================================1D plot: R vs phi , different eta, depth=2
14952  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
14953  c3x5->Clear();
14955  c3x5->Divide(4, 4);
14956  c3x5->cd(1);
14957  int kcountHBpositivedirectionReconoiseDIF2 = 1;
14958  TH1F *h2CeffHBpositivedirectionReconoiseDIF2 = new TH1F("h2CeffHBpositivedirectionReconoiseDIF2", "", nphi, 0., 72.);
14959  for (int jeta = 0; jeta < njeta; jeta++) {
14960  // positivedirectionReconoiseDIF:
14961  if (jeta - 41 >= 0 && jeta - 41 <= 15) {
14962  // for (int i=0;i<ndepth;i++) {
14963  // depth=2
14964  for (int i = 1; i < 2; i++) {
14965  TH1F *HBpositivedirectionReconoiseDIF2 = (TH1F *)h2CeffHBpositivedirectionReconoiseDIF2->Clone("twod1");
14966  float ccctest = 0; // to avoid empty massive elements
14967  for (int jphi = 0; jphi < nphi; jphi++) {
14968  double ccc1 = breconoiseHB[i][jeta][jphi];
14969  if (ccc1 != 0.) {
14970  HBpositivedirectionReconoiseDIF2->Fill(jphi, ccc1);
14971  ccctest = 1.; //HBpositivedirectionReconoiseDIF2->SetBinError(i,0.01);
14972  }
14973  } // for jphi
14974  if (ccctest > 0.) {
14975  //cout<<"555 kcountHBpositivedirectionReconoiseDIF2 = "<<kcountHBpositivedirectionReconoiseDIF2 <<" jeta-41= "<< jeta-41 <<endl;
14976  c3x5->cd(kcountHBpositivedirectionReconoiseDIF2);
14977  HBpositivedirectionReconoiseDIF2->SetMarkerStyle(20);
14978  HBpositivedirectionReconoiseDIF2->SetMarkerSize(0.4);
14979  HBpositivedirectionReconoiseDIF2->GetYaxis()->SetLabelSize(0.04);
14980  HBpositivedirectionReconoiseDIF2->SetXTitle("HBpositivedirectionReconoiseDIF2 \b");
14981  HBpositivedirectionReconoiseDIF2->SetMarkerColor(2);
14982  HBpositivedirectionReconoiseDIF2->SetLineColor(0);
14983  gPad->SetGridy();
14984  gPad->SetGridx();
14985  // gPad->SetLogy();
14986  if (kcountHBpositivedirectionReconoiseDIF2 == 1)
14987  HBpositivedirectionReconoiseDIF2->SetXTitle("DIF for HB+ jeta = 0; depth = 2 \b");
14988  if (kcountHBpositivedirectionReconoiseDIF2 == 2)
14989  HBpositivedirectionReconoiseDIF2->SetXTitle("DIF for HB+ jeta = 1; depth = 2 \b");
14990  if (kcountHBpositivedirectionReconoiseDIF2 == 3)
14991  HBpositivedirectionReconoiseDIF2->SetXTitle("DIF for HB+ jeta = 2; depth = 2 \b");
14992  if (kcountHBpositivedirectionReconoiseDIF2 == 4)
14993  HBpositivedirectionReconoiseDIF2->SetXTitle("DIF for HB+ jeta = 3; depth = 2 \b");
14994  if (kcountHBpositivedirectionReconoiseDIF2 == 5)
14995  HBpositivedirectionReconoiseDIF2->SetXTitle("DIF for HB+ jeta = 4; depth = 2 \b");
14996  if (kcountHBpositivedirectionReconoiseDIF2 == 6)
14997  HBpositivedirectionReconoiseDIF2->SetXTitle("DIF for HB+ jeta = 5; depth = 2 \b");
14998  if (kcountHBpositivedirectionReconoiseDIF2 == 7)
14999  HBpositivedirectionReconoiseDIF2->SetXTitle("DIF for HB+ jeta = 6; depth = 2 \b");
15000  if (kcountHBpositivedirectionReconoiseDIF2 == 8)
15001  HBpositivedirectionReconoiseDIF2->SetXTitle("DIF for HB+ jeta = 7; depth = 2 \b");
15002  if (kcountHBpositivedirectionReconoiseDIF2 == 9)
15003  HBpositivedirectionReconoiseDIF2->SetXTitle("DIF for HB+ jeta = 8; depth = 2 \b");
15004  if (kcountHBpositivedirectionReconoiseDIF2 == 10)
15005  HBpositivedirectionReconoiseDIF2->SetXTitle("DIF for HB+ jeta = 9; depth = 2 \b");
15006  if (kcountHBpositivedirectionReconoiseDIF2 == 11)
15007  HBpositivedirectionReconoiseDIF2->SetXTitle("DIF for HB+ jeta = 10; depth = 2 \b");
15008  if (kcountHBpositivedirectionReconoiseDIF2 == 12)
15009  HBpositivedirectionReconoiseDIF2->SetXTitle("DIF for HB+ jeta = 11; depth = 2 \b");
15010  if (kcountHBpositivedirectionReconoiseDIF2 == 13)
15011  HBpositivedirectionReconoiseDIF2->SetXTitle("DIF for HB+ jeta = 12; depth = 2 \b");
15012  if (kcountHBpositivedirectionReconoiseDIF2 == 14)
15013  HBpositivedirectionReconoiseDIF2->SetXTitle("DIF for HB+ jeta = 13; depth = 2 \b");
15014  if (kcountHBpositivedirectionReconoiseDIF2 == 15)
15015  HBpositivedirectionReconoiseDIF2->SetXTitle("DIF for HB+ jeta = 14; depth = 2 \b");
15016  if (kcountHBpositivedirectionReconoiseDIF2 == 16)
15017  HBpositivedirectionReconoiseDIF2->SetXTitle("DIF for HB+ jeta = 15; depth = 2 \b");
15018  HBpositivedirectionReconoiseDIF2->Draw("Error");
15019  kcountHBpositivedirectionReconoiseDIF2++;
15020  if (kcountHBpositivedirectionReconoiseDIF2 > 16)
15021  break; // 4x6 = 24
15022  } //ccctest>0
15023 
15024  } // for i
15025  } //if(jeta-41 >= 0)
15026  } //for jeta
15028  c3x5->Update();
15029  c3x5->Print("DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth2HB.png");
15030  c3x5->Clear();
15031  // clean-up
15032  if (h2CeffHBpositivedirectionReconoiseDIF2)
15033  delete h2CeffHBpositivedirectionReconoiseDIF2;
15034  //========================================================================================== 6
15035  //======================================================================
15036  //======================================================================1D plot: R vs phi , different eta, depth=3
15037  //cout<<" 1D plot: R vs phi , different eta, depth=3 *****" <<endl;
15038  c3x5->Clear();
15040  c3x5->Divide(4, 4);
15041  c3x5->cd(1);
15042  int kcountHBpositivedirectionReconoiseDIF3 = 1;
15043  TH1F *h2CeffHBpositivedirectionReconoiseDIF3 = new TH1F("h2CeffHBpositivedirectionReconoiseDIF3", "", nphi, 0., 72.);
15044  for (int jeta = 0; jeta < njeta; jeta++) {
15045  // positivedirectionReconoiseDIF:
15046  if (jeta - 41 >= 0 && jeta - 41 <= 15) {
15047  // for (int i=0;i<ndepth;i++) {
15048  // depth=3
15049  for (int i = 2; i < 3; i++) {
15050  TH1F *HBpositivedirectionReconoiseDIF3 = (TH1F *)h2CeffHBpositivedirectionReconoiseDIF3->Clone("twod1");
15051  float ccctest = 0; // to avoid empty massive elements
15052  for (int jphi = 0; jphi < nphi; jphi++) {
15053  double ccc1 = breconoiseHB[i][jeta][jphi];
15054  if (ccc1 != 0.) {
15055  HBpositivedirectionReconoiseDIF3->Fill(jphi, ccc1);
15056  ccctest = 1.; //HBpositivedirectionReconoiseDIF3->SetBinError(i,0.01);
15057  }
15058  } // for jphi
15059  if (ccctest > 0.) {
15060  //cout<<"666 kcountHBpositivedirectionReconoiseDIF3 = "<<kcountHBpositivedirectionReconoiseDIF3 <<" jeta-41= "<< jeta-41 <<endl;
15061  c3x5->cd(kcountHBpositivedirectionReconoiseDIF3);
15062  HBpositivedirectionReconoiseDIF3->SetMarkerStyle(20);
15063  HBpositivedirectionReconoiseDIF3->SetMarkerSize(0.4);
15064  HBpositivedirectionReconoiseDIF3->GetYaxis()->SetLabelSize(0.04);
15065  HBpositivedirectionReconoiseDIF3->SetXTitle("HBpositivedirectionReconoiseDIF3 \b");
15066  HBpositivedirectionReconoiseDIF3->SetMarkerColor(2);
15067  HBpositivedirectionReconoiseDIF3->SetLineColor(0);
15068  gPad->SetGridy();
15069  gPad->SetGridx();
15070  // gPad->SetLogy();
15071  if (kcountHBpositivedirectionReconoiseDIF3 == 1)
15072  HBpositivedirectionReconoiseDIF3->SetXTitle("DIF for HB+ jeta = 0; depth = 3 \b");
15073  if (kcountHBpositivedirectionReconoiseDIF3 == 2)
15074  HBpositivedirectionReconoiseDIF3->SetXTitle("DIF for HB+ jeta = 1; depth = 3 \b");
15075  if (kcountHBpositivedirectionReconoiseDIF3 == 3)
15076  HBpositivedirectionReconoiseDIF3->SetXTitle("DIF for HB+ jeta = 2; depth = 3 \b");
15077  if (kcountHBpositivedirectionReconoiseDIF3 == 4)
15078  HBpositivedirectionReconoiseDIF3->SetXTitle("DIF for HB+ jeta = 3; depth = 3 \b");
15079  if (kcountHBpositivedirectionReconoiseDIF3 == 5)
15080  HBpositivedirectionReconoiseDIF3->SetXTitle("DIF for HB+ jeta = 4; depth = 3 \b");
15081  if (kcountHBpositivedirectionReconoiseDIF3 == 6)
15082  HBpositivedirectionReconoiseDIF3->SetXTitle("DIF for HB+ jeta = 5; depth = 3 \b");
15083  if (kcountHBpositivedirectionReconoiseDIF3 == 7)
15084  HBpositivedirectionReconoiseDIF3->SetXTitle("DIF for HB+ jeta = 6; depth = 3 \b");
15085  if (kcountHBpositivedirectionReconoiseDIF3 == 8)
15086  HBpositivedirectionReconoiseDIF3->SetXTitle("DIF for HB+ jeta = 7; depth = 3 \b");
15087  if (kcountHBpositivedirectionReconoiseDIF3 == 9)
15088  HBpositivedirectionReconoiseDIF3->SetXTitle("DIF for HB+ jeta = 8; depth = 3 \b");
15089  if (kcountHBpositivedirectionReconoiseDIF3 == 10)
15090  HBpositivedirectionReconoiseDIF3->SetXTitle("DIF for HB+ jeta = 9; depth = 3 \b");
15091  if (kcountHBpositivedirectionReconoiseDIF3 == 11)
15092  HBpositivedirectionReconoiseDIF3->SetXTitle("DIF for HB+ jeta = 0; depth = 3 \b");
15093  if (kcountHBpositivedirectionReconoiseDIF3 == 12)
15094  HBpositivedirectionReconoiseDIF3->SetXTitle("DIF for HB+ jeta = 11; depth = 3 \b");
15095  if (kcountHBpositivedirectionReconoiseDIF3 == 13)
15096  HBpositivedirectionReconoiseDIF3->SetXTitle("DIF for HB+ jeta = 12; depth = 3 \b");
15097  if (kcountHBpositivedirectionReconoiseDIF3 == 14)
15098  HBpositivedirectionReconoiseDIF3->SetXTitle("DIF for HB+ jeta = 13; depth = 3 \b");
15099  if (kcountHBpositivedirectionReconoiseDIF3 == 15)
15100  HBpositivedirectionReconoiseDIF3->SetXTitle("DIF for HB+ jeta = 14; depth = 3 \b");
15101  if (kcountHBpositivedirectionReconoiseDIF3 == 16)
15102  HBpositivedirectionReconoiseDIF3->SetXTitle("DIF for HB+ jeta = 15; depth = 3 \b");
15103  HBpositivedirectionReconoiseDIF3->Draw("Error");
15104  kcountHBpositivedirectionReconoiseDIF3++;
15105  if (kcountHBpositivedirectionReconoiseDIF3 > 16)
15106  break; // 4x6 = 24
15107  } //ccctest>0
15108 
15109  } // for i
15110  } //if(jeta-41 >= 0)
15111  } //for jeta
15113  c3x5->Update();
15114  c3x5->Print("DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth3HB.png");
15115  c3x5->Clear();
15116  // clean-up
15117  if (h2CeffHBpositivedirectionReconoiseDIF3)
15118  delete h2CeffHBpositivedirectionReconoiseDIF3;
15119  //========================================================================================== 7
15120  //======================================================================
15121  //======================================================================1D plot: R vs phi , different eta, depth=4
15122  //cout<<" 1D plot: R vs phi , different eta, depth=4 *****" <<endl;
15123  c3x5->Clear();
15125  c3x5->Divide(4, 4);
15126  c3x5->cd(1);
15127  int kcountHBpositivedirectionReconoiseDIF4 = 1;
15128  TH1F *h2CeffHBpositivedirectionReconoiseDIF4 = new TH1F("h2CeffHBpositivedirectionReconoiseDIF4", "", nphi, 0., 72.);
15129 
15130  for (int jeta = 0; jeta < njeta; jeta++) {
15131  // positivedirectionReconoiseDIF:
15132  if (jeta - 41 >= 0 && jeta - 41 <= 15) {
15133  // for (int i=0;i<ndepth;i++) {
15134  // depth=4
15135  for (int i = 3; i < 4; i++) {
15136  TH1F *HBpositivedirectionReconoiseDIF4 = (TH1F *)h2CeffHBpositivedirectionReconoiseDIF4->Clone("twod1");
15137 
15138  float ccctest = 0; // to avoid empty massive elements
15139  for (int jphi = 0; jphi < nphi; jphi++) {
15140  double ccc1 = breconoiseHB[i][jeta][jphi];
15141  if (ccc1 != 0.) {
15142  HBpositivedirectionReconoiseDIF4->Fill(jphi, ccc1);
15143  ccctest = 1.; //HBpositivedirectionReconoiseDIF4->SetBinError(i,0.01);
15144  }
15145  } // for jphi
15146  if (ccctest > 0.) {
15147  //cout<<"777 kcountHBpositivedirectionReconoiseDIF4 = "<<kcountHBpositivedirectionReconoiseDIF4 <<" jeta-41= "<< jeta-41 <<endl;
15148  c3x5->cd(kcountHBpositivedirectionReconoiseDIF4);
15149  HBpositivedirectionReconoiseDIF4->SetMarkerStyle(20);
15150  HBpositivedirectionReconoiseDIF4->SetMarkerSize(0.4);
15151  HBpositivedirectionReconoiseDIF4->GetYaxis()->SetLabelSize(0.04);
15152  HBpositivedirectionReconoiseDIF4->SetXTitle("HBpositivedirectionReconoiseDIF4 \b");
15153  HBpositivedirectionReconoiseDIF4->SetMarkerColor(2);
15154  HBpositivedirectionReconoiseDIF4->SetLineColor(0);
15155  gPad->SetGridy();
15156  gPad->SetGridx();
15157  // gPad->SetLogy();
15158  if (kcountHBpositivedirectionReconoiseDIF4 == 1)
15159  HBpositivedirectionReconoiseDIF4->SetXTitle("DIF for HB+ jeta = 0; depth = 4 \b");
15160  if (kcountHBpositivedirectionReconoiseDIF4 == 2)
15161  HBpositivedirectionReconoiseDIF4->SetXTitle("DIF for HB+ jeta = 1; depth = 4 \b");
15162  if (kcountHBpositivedirectionReconoiseDIF4 == 3)
15163  HBpositivedirectionReconoiseDIF4->SetXTitle("DIF for HB+ jeta = 2; depth = 4 \b");
15164  if (kcountHBpositivedirectionReconoiseDIF4 == 4)
15165  HBpositivedirectionReconoiseDIF4->SetXTitle("DIF for HB+ jeta = 3; depth = 4 \b");
15166  if (kcountHBpositivedirectionReconoiseDIF4 == 5)
15167  HBpositivedirectionReconoiseDIF4->SetXTitle("DIF for HB+ jeta = 4; depth = 4 \b");
15168  if (kcountHBpositivedirectionReconoiseDIF4 == 6)
15169  HBpositivedirectionReconoiseDIF4->SetXTitle("DIF for HB+ jeta = 5; depth = 4 \b");
15170  if (kcountHBpositivedirectionReconoiseDIF4 == 7)
15171  HBpositivedirectionReconoiseDIF4->SetXTitle("DIF for HB+ jeta = 6; depth = 4 \b");
15172  if (kcountHBpositivedirectionReconoiseDIF4 == 8)
15173  HBpositivedirectionReconoiseDIF4->SetXTitle("DIF for HB+ jeta = 7; depth = 4 \b");
15174  if (kcountHBpositivedirectionReconoiseDIF4 == 9)
15175  HBpositivedirectionReconoiseDIF4->SetXTitle("DIF for HB+ jeta = 8; depth = 4 \b");
15176  if (kcountHBpositivedirectionReconoiseDIF4 == 10)
15177  HBpositivedirectionReconoiseDIF4->SetXTitle("DIF for HB+ jeta = 9; depth = 4 \b");
15178  if (kcountHBpositivedirectionReconoiseDIF4 == 11)
15179  HBpositivedirectionReconoiseDIF4->SetXTitle("DIF for HB+ jeta = 10; depth = 4 \b");
15180  if (kcountHBpositivedirectionReconoiseDIF4 == 12)
15181  HBpositivedirectionReconoiseDIF4->SetXTitle("DIF for HB+ jeta = 11; depth = 4 \b");
15182  if (kcountHBpositivedirectionReconoiseDIF4 == 13)
15183  HBpositivedirectionReconoiseDIF4->SetXTitle("DIF for HB+ jeta = 12; depth = 4 \b");
15184  if (kcountHBpositivedirectionReconoiseDIF4 == 14)
15185  HBpositivedirectionReconoiseDIF4->SetXTitle("DIF for HB+ jeta = 13; depth = 4 \b");
15186  if (kcountHBpositivedirectionReconoiseDIF4 == 15)
15187  HBpositivedirectionReconoiseDIF4->SetXTitle("DIF for HB+ jeta = 14; depth = 4 \b");
15188  if (kcountHBpositivedirectionReconoiseDIF4 == 16)
15189  HBpositivedirectionReconoiseDIF4->SetXTitle("DIF for HB+ jeta = 15; depth = 4 \b");
15190  HBpositivedirectionReconoiseDIF4->Draw("Error");
15191  kcountHBpositivedirectionReconoiseDIF4++;
15192  if (kcountHBpositivedirectionReconoiseDIF4 > 16)
15193  break; // 4x6 = 24
15194  } //ccctest>0
15195 
15196  } // for i
15197  } //if(jeta-41 >= 0)
15198  } //for jeta
15200  c3x5->Update();
15201  c3x5->Print("DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth4HB.png");
15202  c3x5->Clear();
15203  // clean-up
15204  if (h2CeffHBpositivedirectionReconoiseDIF4)
15205  delete h2CeffHBpositivedirectionReconoiseDIF4;
15206 
15207  //========================================================================================== 1114
15208  //======================================================================
15209  //======================================================================1D plot: R vs phi , different eta, depth=1
15210  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
15211  c3x5->Clear();
15213  c3x5->Divide(4, 4);
15214  c3x5->cd(1);
15215  int kcountHBnegativedirectionReconoiseDIF1 = 1;
15216  TH1F *h2CeffHBnegativedirectionReconoiseDIF1 = new TH1F("h2CeffHBnegativedirectionReconoiseDIF1", "", nphi, 0., 72.);
15217  for (int jeta = 0; jeta < njeta; jeta++) {
15218  // negativedirectionReconoiseDIF:
15219  if (jeta - 41 >= -16 && jeta - 41 <= -1) {
15220  // for (int i=0;i<ndepth;i++) {
15221  // depth=1
15222  for (int i = 0; i < 1; i++) {
15223  TH1F *HBnegativedirectionReconoiseDIF1 = (TH1F *)h2CeffHBnegativedirectionReconoiseDIF1->Clone("twod1");
15224  float ccctest = 0; // to avoid empty massive elements
15225  for (int jphi = 0; jphi < nphi; jphi++) {
15226  double ccc1 = breconoiseHB[i][jeta][jphi];
15227  if (ccc1 != 0.) {
15228  HBnegativedirectionReconoiseDIF1->Fill(jphi, ccc1);
15229  ccctest = 1.; //HBnegativedirectionReconoiseDIF1->SetBinError(i,0.01);
15230  }
15231  } // for jphi
15232  if (ccctest > 0.) {
15233  // cout<<"444 kcountHBnegativedirectionReconoiseDIF1 = "<<kcountHBnegativedirectionReconoiseDIF1 <<" jeta-41= "<< jeta-41 <<endl;
15234  c3x5->cd(kcountHBnegativedirectionReconoiseDIF1);
15235  HBnegativedirectionReconoiseDIF1->SetMarkerStyle(20);
15236  HBnegativedirectionReconoiseDIF1->SetMarkerSize(0.4);
15237  HBnegativedirectionReconoiseDIF1->GetYaxis()->SetLabelSize(0.04);
15238  HBnegativedirectionReconoiseDIF1->SetXTitle("HBnegativedirectionReconoiseDIF1 \b");
15239  HBnegativedirectionReconoiseDIF1->SetMarkerColor(2);
15240  HBnegativedirectionReconoiseDIF1->SetLineColor(0);
15241  gPad->SetGridy();
15242  gPad->SetGridx();
15243  // gPad->SetLogy();
15244  if (kcountHBnegativedirectionReconoiseDIF1 == 1)
15245  HBnegativedirectionReconoiseDIF1->SetXTitle("DIF for HB- jeta = -16; depth = 1 \b");
15246  if (kcountHBnegativedirectionReconoiseDIF1 == 2)
15247  HBnegativedirectionReconoiseDIF1->SetXTitle("DIF for HB- jeta = -15; depth = 1 \b");
15248  if (kcountHBnegativedirectionReconoiseDIF1 == 3)
15249  HBnegativedirectionReconoiseDIF1->SetXTitle("DIF for HB- jeta = -14; depth = 1 \b");
15250  if (kcountHBnegativedirectionReconoiseDIF1 == 4)
15251  HBnegativedirectionReconoiseDIF1->SetXTitle("DIF for HB- jeta = -13; depth = 1 \b");
15252  if (kcountHBnegativedirectionReconoiseDIF1 == 5)
15253  HBnegativedirectionReconoiseDIF1->SetXTitle("DIF for HB- jeta = -12; depth = 1 \b");
15254  if (kcountHBnegativedirectionReconoiseDIF1 == 6)
15255  HBnegativedirectionReconoiseDIF1->SetXTitle("DIF for HB- jeta = -11; depth = 1 \b");
15256  if (kcountHBnegativedirectionReconoiseDIF1 == 7)
15257  HBnegativedirectionReconoiseDIF1->SetXTitle("DIF for HB- jeta = -10; depth = 1 \b");
15258  if (kcountHBnegativedirectionReconoiseDIF1 == 8)
15259  HBnegativedirectionReconoiseDIF1->SetXTitle("DIF for HB- jeta = -9; depth = 1 \b");
15260  if (kcountHBnegativedirectionReconoiseDIF1 == 9)
15261  HBnegativedirectionReconoiseDIF1->SetXTitle("DIF for HB- jeta = -8; depth = 1 \b");
15262  if (kcountHBnegativedirectionReconoiseDIF1 == 10)
15263  HBnegativedirectionReconoiseDIF1->SetXTitle("DIF for HB- jeta = -7; depth = 1 \b");
15264  if (kcountHBnegativedirectionReconoiseDIF1 == 11)
15265  HBnegativedirectionReconoiseDIF1->SetXTitle("DIF for HB- jeta = -6; depth = 1 \b");
15266  if (kcountHBnegativedirectionReconoiseDIF1 == 12)
15267  HBnegativedirectionReconoiseDIF1->SetXTitle("DIF for HB- jeta = -5; depth = 1 \b");
15268  if (kcountHBnegativedirectionReconoiseDIF1 == 13)
15269  HBnegativedirectionReconoiseDIF1->SetXTitle("DIF for HB- jeta = -4; depth = 1 \b");
15270  if (kcountHBnegativedirectionReconoiseDIF1 == 14)
15271  HBnegativedirectionReconoiseDIF1->SetXTitle("DIF for HB- jeta = -3; depth = 1 \b");
15272  if (kcountHBnegativedirectionReconoiseDIF1 == 15)
15273  HBnegativedirectionReconoiseDIF1->SetXTitle("DIF for HB- jeta = -2; depth = 1 \b");
15274  if (kcountHBnegativedirectionReconoiseDIF1 == 16)
15275  HBnegativedirectionReconoiseDIF1->SetXTitle("DIF for HB- jeta = -1; depth = 1 \b");
15276  HBnegativedirectionReconoiseDIF1->Draw("Error");
15277  kcountHBnegativedirectionReconoiseDIF1++;
15278  if (kcountHBnegativedirectionReconoiseDIF1 > 16)
15279  break; //
15280  } //ccctest>0
15281 
15282  } // for i
15283  } //if(jeta-41 < 0 )
15284  } //for jeta
15286  c3x5->Update();
15287  c3x5->Print("DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth1HB.png");
15288  c3x5->Clear();
15289  // clean-up
15290  if (h2CeffHBnegativedirectionReconoiseDIF1)
15291  delete h2CeffHBnegativedirectionReconoiseDIF1;
15292 
15293  //========================================================================================== 1115
15294  //======================================================================
15295  //======================================================================1D plot: R vs phi , different eta, depth=2
15296  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
15297  c3x5->Clear();
15299  c3x5->Divide(4, 4);
15300  c3x5->cd(1);
15301  int kcountHBnegativedirectionReconoiseDIF2 = 1;
15302  TH1F *h2CeffHBnegativedirectionReconoiseDIF2 = new TH1F("h2CeffHBnegativedirectionReconoiseDIF2", "", nphi, 0., 72.);
15303  for (int jeta = 0; jeta < njeta; jeta++) {
15304  // negativedirectionReconoiseDIF:
15305  if (jeta - 41 >= -16 && jeta - 41 <= -1) {
15306  // for (int i=0;i<ndepth;i++) {
15307  // depth=2
15308  for (int i = 1; i < 2; i++) {
15309  TH1F *HBnegativedirectionReconoiseDIF2 = (TH1F *)h2CeffHBnegativedirectionReconoiseDIF2->Clone("twod1");
15310  float ccctest = 0; // to avoid empty massive elements
15311  for (int jphi = 0; jphi < nphi; jphi++) {
15312  double ccc1 = breconoiseHB[i][jeta][jphi];
15313  if (ccc1 != 0.) {
15314  HBnegativedirectionReconoiseDIF2->Fill(jphi, ccc1);
15315  ccctest = 1.; //HBnegativedirectionReconoiseDIF2->SetBinError(i,0.01);
15316  }
15317  } // for jphi
15318  if (ccctest > 0.) {
15319  //cout<<"555 kcountHBnegativedirectionReconoiseDIF2 = "<<kcountHBnegativedirectionReconoiseDIF2 <<" jeta-41= "<< jeta-41 <<endl;
15320  c3x5->cd(kcountHBnegativedirectionReconoiseDIF2);
15321  HBnegativedirectionReconoiseDIF2->SetMarkerStyle(20);
15322  HBnegativedirectionReconoiseDIF2->SetMarkerSize(0.4);
15323  HBnegativedirectionReconoiseDIF2->GetYaxis()->SetLabelSize(0.04);
15324  HBnegativedirectionReconoiseDIF2->SetXTitle("HBnegativedirectionReconoiseDIF2 \b");
15325  HBnegativedirectionReconoiseDIF2->SetMarkerColor(2);
15326  HBnegativedirectionReconoiseDIF2->SetLineColor(0);
15327  gPad->SetGridy();
15328  gPad->SetGridx();
15329  // gPad->SetLogy();
15330  if (kcountHBnegativedirectionReconoiseDIF2 == 1)
15331  HBnegativedirectionReconoiseDIF2->SetXTitle("DIF for HB- jeta = -16; depth = 2 \b");
15332  if (kcountHBnegativedirectionReconoiseDIF2 == 2)
15333  HBnegativedirectionReconoiseDIF2->SetXTitle("DIF for HB- jeta = -15; depth = 2 \b");
15334  if (kcountHBnegativedirectionReconoiseDIF2 == 3)
15335  HBnegativedirectionReconoiseDIF2->SetXTitle("DIF for HB- jeta = -14; depth = 2 \b");
15336  if (kcountHBnegativedirectionReconoiseDIF2 == 4)
15337  HBnegativedirectionReconoiseDIF2->SetXTitle("DIF for HB- jeta = -13; depth = 2 \b");
15338  if (kcountHBnegativedirectionReconoiseDIF2 == 5)
15339  HBnegativedirectionReconoiseDIF2->SetXTitle("DIF for HB- jeta = -12; depth = 2 \b");
15340  if (kcountHBnegativedirectionReconoiseDIF2 == 6)
15341  HBnegativedirectionReconoiseDIF2->SetXTitle("DIF for HB- jeta = -11; depth = 2 \b");
15342  if (kcountHBnegativedirectionReconoiseDIF2 == 7)
15343  HBnegativedirectionReconoiseDIF2->SetXTitle("DIF for HB- jeta = -10; depth = 2 \b");
15344  if (kcountHBnegativedirectionReconoiseDIF2 == 8)
15345  HBnegativedirectionReconoiseDIF2->SetXTitle("DIF for HB- jeta = -9; depth = 2 \b");
15346  if (kcountHBnegativedirectionReconoiseDIF2 == 9)
15347  HBnegativedirectionReconoiseDIF2->SetXTitle("DIF for HB- jeta = -8; depth = 2 \b");
15348  if (kcountHBnegativedirectionReconoiseDIF2 == 10)
15349  HBnegativedirectionReconoiseDIF2->SetXTitle("DIF for HB- jeta = -7; depth = 2 \b");
15350  if (kcountHBnegativedirectionReconoiseDIF2 == 11)
15351  HBnegativedirectionReconoiseDIF2->SetXTitle("DIF for HB- jeta = -6; depth = 2 \b");
15352  if (kcountHBnegativedirectionReconoiseDIF2 == 12)
15353  HBnegativedirectionReconoiseDIF2->SetXTitle("DIF for HB- jeta = -5; depth = 2 \b");
15354  if (kcountHBnegativedirectionReconoiseDIF2 == 13)
15355  HBnegativedirectionReconoiseDIF2->SetXTitle("DIF for HB- jeta = -4; depth = 2 \b");
15356  if (kcountHBnegativedirectionReconoiseDIF2 == 14)
15357  HBnegativedirectionReconoiseDIF2->SetXTitle("DIF for HB- jeta = -3; depth = 2 \b");
15358  if (kcountHBnegativedirectionReconoiseDIF2 == 15)
15359  HBnegativedirectionReconoiseDIF2->SetXTitle("DIF for HB- jeta = -2; depth = 2 \b");
15360  if (kcountHBnegativedirectionReconoiseDIF2 == 16)
15361  HBnegativedirectionReconoiseDIF2->SetXTitle("DIF for HB- jeta = -1; depth = 2 \b");
15362  HBnegativedirectionReconoiseDIF2->Draw("Error");
15363  kcountHBnegativedirectionReconoiseDIF2++;
15364  if (kcountHBnegativedirectionReconoiseDIF2 > 16)
15365  break; // 4x6 = 24
15366  } //ccctest>0
15367 
15368  } // for i
15369  } //if(jeta-41 < 0 )
15370  } //for jeta
15372  c3x5->Update();
15373  c3x5->Print("DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth2HB.png");
15374  c3x5->Clear();
15375  // clean-up
15376  if (h2CeffHBnegativedirectionReconoiseDIF2)
15377  delete h2CeffHBnegativedirectionReconoiseDIF2;
15378  //========================================================================================== 1116
15379  //======================================================================
15380  //======================================================================1D plot: R vs phi , different eta, depth=3
15381  //cout<<" 1D plot: R vs phi , different eta, depth=3 *****" <<endl;
15382  c3x5->Clear();
15384  c3x5->Divide(4, 4);
15385  c3x5->cd(1);
15386  int kcountHBnegativedirectionReconoiseDIF3 = 1;
15387  TH1F *h2CeffHBnegativedirectionReconoiseDIF3 = new TH1F("h2CeffHBnegativedirectionReconoiseDIF3", "", nphi, 0., 72.);
15388  for (int jeta = 0; jeta < njeta; jeta++) {
15389  // negativedirectionReconoiseDIF:
15390  if (jeta - 41 >= -16 && jeta - 41 <= -1) {
15391  // for (int i=0;i<ndepth;i++) {
15392  // depth=3
15393  for (int i = 2; i < 3; i++) {
15394  TH1F *HBnegativedirectionReconoiseDIF3 = (TH1F *)h2CeffHBnegativedirectionReconoiseDIF3->Clone("twod1");
15395  float ccctest = 0; // to avoid empty massive elements
15396  for (int jphi = 0; jphi < nphi; jphi++) {
15397  double ccc1 = breconoiseHB[i][jeta][jphi];
15398  if (ccc1 != 0.) {
15399  HBnegativedirectionReconoiseDIF3->Fill(jphi, ccc1);
15400  ccctest = 1.; //HBnegativedirectionReconoiseDIF3->SetBinError(i,0.01);
15401  }
15402  } // for jphi
15403  if (ccctest > 0.) {
15404  //cout<<"666 kcountHBnegativedirectionReconoiseDIF3 = "<<kcountHBnegativedirectionReconoiseDIF3 <<" jeta-41= "<< jeta-41 <<endl;
15405  c3x5->cd(kcountHBnegativedirectionReconoiseDIF3);
15406  HBnegativedirectionReconoiseDIF3->SetMarkerStyle(20);
15407  HBnegativedirectionReconoiseDIF3->SetMarkerSize(0.4);
15408  HBnegativedirectionReconoiseDIF3->GetYaxis()->SetLabelSize(0.04);
15409  HBnegativedirectionReconoiseDIF3->SetXTitle("HBnegativedirectionReconoiseDIF3 \b");
15410  HBnegativedirectionReconoiseDIF3->SetMarkerColor(2);
15411  HBnegativedirectionReconoiseDIF3->SetLineColor(0);
15412  gPad->SetGridy();
15413  gPad->SetGridx();
15414  // gPad->SetLogy();
15415  if (kcountHBnegativedirectionReconoiseDIF3 == 1)
15416  HBnegativedirectionReconoiseDIF3->SetXTitle("DIF for HB- jeta = -16; depth = 3 \b");
15417  if (kcountHBnegativedirectionReconoiseDIF3 == 2)
15418  HBnegativedirectionReconoiseDIF3->SetXTitle("DIF for HB- jeta = -15; depth = 3 \b");
15419  if (kcountHBnegativedirectionReconoiseDIF3 == 3)
15420  HBnegativedirectionReconoiseDIF3->SetXTitle("DIF for HB- jeta = -14; depth = 3 \b");
15421  if (kcountHBnegativedirectionReconoiseDIF3 == 4)
15422  HBnegativedirectionReconoiseDIF3->SetXTitle("DIF for HB- jeta = -13; depth = 3 \b");
15423  if (kcountHBnegativedirectionReconoiseDIF3 == 5)
15424  HBnegativedirectionReconoiseDIF3->SetXTitle("DIF for HB- jeta = -12; depth = 3 \b");
15425  if (kcountHBnegativedirectionReconoiseDIF3 == 6)
15426  HBnegativedirectionReconoiseDIF3->SetXTitle("DIF for HB- jeta = -11; depth = 3 \b");
15427  if (kcountHBnegativedirectionReconoiseDIF3 == 7)
15428  HBnegativedirectionReconoiseDIF3->SetXTitle("DIF for HB- jeta = -10; depth = 3 \b");
15429  if (kcountHBnegativedirectionReconoiseDIF3 == 8)
15430  HBnegativedirectionReconoiseDIF3->SetXTitle("DIF for HB- jeta = -9; depth = 3 \b");
15431  if (kcountHBnegativedirectionReconoiseDIF3 == 9)
15432  HBnegativedirectionReconoiseDIF3->SetXTitle("DIF for HB- jeta = -8; depth = 3 \b");
15433  if (kcountHBnegativedirectionReconoiseDIF3 == 10)
15434  HBnegativedirectionReconoiseDIF3->SetXTitle("DIF for HB- jeta = -7; depth = 3 \b");
15435  if (kcountHBnegativedirectionReconoiseDIF3 == 11)
15436  HBnegativedirectionReconoiseDIF3->SetXTitle("DIF for HB- jeta = -6; depth = 3 \b");
15437  if (kcountHBnegativedirectionReconoiseDIF3 == 12)
15438  HBnegativedirectionReconoiseDIF3->SetXTitle("DIF for HB- jeta = -5; depth = 3 \b");
15439  if (kcountHBnegativedirectionReconoiseDIF3 == 13)
15440  HBnegativedirectionReconoiseDIF3->SetXTitle("DIF for HB- jeta = -4; depth = 3 \b");
15441  if (kcountHBnegativedirectionReconoiseDIF3 == 14)
15442  HBnegativedirectionReconoiseDIF3->SetXTitle("DIF for HB- jeta = -3; depth = 3 \b");
15443  if (kcountHBnegativedirectionReconoiseDIF3 == 15)
15444  HBnegativedirectionReconoiseDIF3->SetXTitle("DIF for HB- jeta = -2; depth = 3 \b");
15445  if (kcountHBnegativedirectionReconoiseDIF3 == 16)
15446  HBnegativedirectionReconoiseDIF3->SetXTitle("DIF for HB- jeta = -1; depth = 3 \b");
15447 
15448  HBnegativedirectionReconoiseDIF3->Draw("Error");
15449  kcountHBnegativedirectionReconoiseDIF3++;
15450  if (kcountHBnegativedirectionReconoiseDIF3 > 16)
15451  break; // 4x6 = 24
15452  } //ccctest>0
15453 
15454  } // for i
15455  } //if(jeta-41 < 0 )
15456  } //for jeta
15458  c3x5->Update();
15459  c3x5->Print("DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth3HB.png");
15460  c3x5->Clear();
15461  // clean-up
15462  if (h2CeffHBnegativedirectionReconoiseDIF3)
15463  delete h2CeffHBnegativedirectionReconoiseDIF3;
15464  //========================================================================================== 1117
15465  //======================================================================
15466  //======================================================================1D plot: R vs phi , different eta, depth=4
15467  //cout<<" 1D plot: R vs phi , different eta, depth=4 *****" <<endl;
15468  c3x5->Clear();
15470  c3x5->Divide(4, 4);
15471  c3x5->cd(1);
15472  int kcountHBnegativedirectionReconoiseDIF4 = 1;
15473  TH1F *h2CeffHBnegativedirectionReconoiseDIF4 = new TH1F("h2CeffHBnegativedirectionReconoiseDIF4", "", nphi, 0., 72.);
15474 
15475  for (int jeta = 0; jeta < njeta; jeta++) {
15476  // negativedirectionReconoiseDIF:
15477  if (jeta - 41 >= -16 && jeta - 41 <= -1) {
15478  // for (int i=0;i<ndepth;i++) {
15479  // depth=4
15480  for (int i = 3; i < 4; i++) {
15481  TH1F *HBnegativedirectionReconoiseDIF4 = (TH1F *)h2CeffHBnegativedirectionReconoiseDIF4->Clone("twod1");
15482 
15483  float ccctest = 0; // to avoid empty massive elements
15484  for (int jphi = 0; jphi < nphi; jphi++) {
15485  double ccc1 = breconoiseHB[i][jeta][jphi];
15486  if (ccc1 != 0.) {
15487  HBnegativedirectionReconoiseDIF4->Fill(jphi, ccc1);
15488  ccctest = 1.; //HBnegativedirectionReconoiseDIF4->SetBinError(i,0.01);
15489  }
15490  } // for jphi
15491  if (ccctest > 0.) {
15492  //cout<<"777 kcountHBnegativedirectionReconoiseDIF4 = "<<kcountHBnegativedirectionReconoiseDIF4 <<" jeta-41= "<< jeta-41 <<endl;
15493  c3x5->cd(kcountHBnegativedirectionReconoiseDIF4);
15494  HBnegativedirectionReconoiseDIF4->SetMarkerStyle(20);
15495  HBnegativedirectionReconoiseDIF4->SetMarkerSize(0.4);
15496  HBnegativedirectionReconoiseDIF4->GetYaxis()->SetLabelSize(0.04);
15497  HBnegativedirectionReconoiseDIF4->SetXTitle("HBnegativedirectionReconoiseDIF4 \b");
15498  HBnegativedirectionReconoiseDIF4->SetMarkerColor(2);
15499  HBnegativedirectionReconoiseDIF4->SetLineColor(0);
15500  gPad->SetGridy();
15501  gPad->SetGridx();
15502  // gPad->SetLogy();
15503  if (kcountHBnegativedirectionReconoiseDIF4 == 1)
15504  HBnegativedirectionReconoiseDIF4->SetXTitle("DIF for HB- jeta = -16; depth = 4 \b");
15505  if (kcountHBnegativedirectionReconoiseDIF4 == 2)
15506  HBnegativedirectionReconoiseDIF4->SetXTitle("DIF for HB- jeta = -15; depth = 4 \b");
15507  if (kcountHBnegativedirectionReconoiseDIF4 == 3)
15508  HBnegativedirectionReconoiseDIF4->SetXTitle("DIF for HB- jeta = -14; depth = 4 \b");
15509  if (kcountHBnegativedirectionReconoiseDIF4 == 4)
15510  HBnegativedirectionReconoiseDIF4->SetXTitle("DIF for HB- jeta = -13; depth = 4 \b");
15511  if (kcountHBnegativedirectionReconoiseDIF4 == 5)
15512  HBnegativedirectionReconoiseDIF4->SetXTitle("DIF for HB- jeta = -12; depth = 4 \b");
15513  if (kcountHBnegativedirectionReconoiseDIF4 == 6)
15514  HBnegativedirectionReconoiseDIF4->SetXTitle("DIF for HB- jeta = -11; depth = 4 \b");
15515  if (kcountHBnegativedirectionReconoiseDIF4 == 7)
15516  HBnegativedirectionReconoiseDIF4->SetXTitle("DIF for HB- jeta = -10; depth = 4 \b");
15517  if (kcountHBnegativedirectionReconoiseDIF4 == 8)
15518  HBnegativedirectionReconoiseDIF4->SetXTitle("DIF for HB- jeta = -9; depth = 4 \b");
15519  if (kcountHBnegativedirectionReconoiseDIF4 == 9)
15520  HBnegativedirectionReconoiseDIF4->SetXTitle("DIF for HB- jeta = -8; depth = 4 \b");
15521  if (kcountHBnegativedirectionReconoiseDIF4 == 10)
15522  HBnegativedirectionReconoiseDIF4->SetXTitle("DIF for HB- jeta = -7; depth = 4 \b");
15523  if (kcountHBnegativedirectionReconoiseDIF4 == 11)
15524  HBnegativedirectionReconoiseDIF4->SetXTitle("DIF for HB- jeta = -6; depth = 4 \b");
15525  if (kcountHBnegativedirectionReconoiseDIF4 == 12)
15526  HBnegativedirectionReconoiseDIF4->SetXTitle("DIF for HB- jeta = -5; depth = 4 \b");
15527  if (kcountHBnegativedirectionReconoiseDIF4 == 13)
15528  HBnegativedirectionReconoiseDIF4->SetXTitle("DIF for HB- jeta = -4; depth = 4 \b");
15529  if (kcountHBnegativedirectionReconoiseDIF4 == 14)
15530  HBnegativedirectionReconoiseDIF4->SetXTitle("DIF for HB- jeta = -3; depth = 4 \b");
15531  if (kcountHBnegativedirectionReconoiseDIF4 == 15)
15532  HBnegativedirectionReconoiseDIF4->SetXTitle("DIF for HB- jeta = -2; depth = 4 \b");
15533  if (kcountHBnegativedirectionReconoiseDIF4 == 16)
15534  HBnegativedirectionReconoiseDIF4->SetXTitle("DIF for HB- jeta = -1; depth = 4 \b");
15535  HBnegativedirectionReconoiseDIF4->Draw("Error");
15536  kcountHBnegativedirectionReconoiseDIF4++;
15537  if (kcountHBnegativedirectionReconoiseDIF4 > 16)
15538  break; // 4x6 = 24
15539  } //ccctest>0
15540 
15541  } // for i
15542  } //if(jeta-41 < 0 )
15543  } //for jeta
15545  c3x5->Update();
15546  c3x5->Print("DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth4HB.png");
15547  c3x5->Clear();
15548  // clean-up
15549  if (h2CeffHBnegativedirectionReconoiseDIF4)
15550  delete h2CeffHBnegativedirectionReconoiseDIF4;
15551 
15552  //======================================================================================================================
15553  //======================================================================================================================
15554  //======================================================================================================================
15555  // DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD:
15556 
15557  //cout<<" Start Vaiance: preparation *****" <<endl;
15558  TH2F *reconoiseVariance1HB1 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy2_HB1");
15559  TH2F *reconoiseVariance0HB1 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HB1");
15560  TH2F *reconoiseVarianceHB1 = (TH2F *)reconoiseVariance1HB1->Clone("reconoiseVarianceHB1");
15561  reconoiseVarianceHB1->Divide(reconoiseVariance1HB1, reconoiseVariance0HB1, 1, 1, "B");
15562  TH2F *reconoiseVariance1HB2 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy2_HB2");
15563  TH2F *reconoiseVariance0HB2 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HB2");
15564  TH2F *reconoiseVarianceHB2 = (TH2F *)reconoiseVariance1HB2->Clone("reconoiseVarianceHB2");
15565  reconoiseVarianceHB2->Divide(reconoiseVariance1HB2, reconoiseVariance0HB2, 1, 1, "B");
15566  TH2F *reconoiseVariance1HB3 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy2_HB3");
15567  TH2F *reconoiseVariance0HB3 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HB3");
15568  TH2F *reconoiseVarianceHB3 = (TH2F *)reconoiseVariance1HB3->Clone("reconoiseVarianceHB3");
15569  reconoiseVarianceHB3->Divide(reconoiseVariance1HB3, reconoiseVariance0HB3, 1, 1, "B");
15570  TH2F *reconoiseVariance1HB4 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy2_HB4");
15571  TH2F *reconoiseVariance0HB4 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HB4");
15572  TH2F *reconoiseVarianceHB4 = (TH2F *)reconoiseVariance1HB4->Clone("reconoiseVarianceHB4");
15573  reconoiseVarianceHB4->Divide(reconoiseVariance1HB4, reconoiseVariance0HB4, 1, 1, "B");
15574  //cout<<" Vaiance: preparation DONE *****" <<endl;
15575  //====================================================================== put Vaiance=Dispersia = Sig**2=<R**2> - (<R>)**2 into massive reconoisevarianceHB
15576  // = sum(R*R)/N - (sum(R)/N)**2
15577  for (int jeta = 0; jeta < njeta; jeta++) {
15578  if ((jeta - 41 >= -16 && jeta - 41 <= -1) || (jeta - 41 >= 0 && jeta - 41 <= 15)) {
15579  //preparation for PHI normalization:
15580  double sumreconoiseHB0 = 0;
15581  int nsumreconoiseHB0 = 0;
15582  double sumreconoiseHB1 = 0;
15583  int nsumreconoiseHB1 = 0;
15584  double sumreconoiseHB2 = 0;
15585  int nsumreconoiseHB2 = 0;
15586  double sumreconoiseHB3 = 0;
15587  int nsumreconoiseHB3 = 0;
15588  for (int jphi = 0; jphi < njphi; jphi++) {
15589  reconoisevarianceHB[0][jeta][jphi] = reconoiseVarianceHB1->GetBinContent(jeta + 1, jphi + 1);
15590  reconoisevarianceHB[1][jeta][jphi] = reconoiseVarianceHB2->GetBinContent(jeta + 1, jphi + 1);
15591  reconoisevarianceHB[2][jeta][jphi] = reconoiseVarianceHB3->GetBinContent(jeta + 1, jphi + 1);
15592  reconoisevarianceHB[3][jeta][jphi] = reconoiseVarianceHB4->GetBinContent(jeta + 1, jphi + 1);
15593  if (reconoisevarianceHB[0][jeta][jphi] != 0.) {
15594  sumreconoiseHB0 += reconoisevarianceHB[0][jeta][jphi];
15595  ++nsumreconoiseHB0;
15596  }
15597  if (reconoisevarianceHB[1][jeta][jphi] != 0.) {
15598  sumreconoiseHB1 += reconoisevarianceHB[1][jeta][jphi];
15599  ++nsumreconoiseHB1;
15600  }
15601  if (reconoisevarianceHB[2][jeta][jphi] != 0.) {
15602  sumreconoiseHB2 += reconoisevarianceHB[2][jeta][jphi];
15603  ++nsumreconoiseHB2;
15604  }
15605  if (reconoisevarianceHB[3][jeta][jphi] != 0.) {
15606  sumreconoiseHB3 += reconoisevarianceHB[3][jeta][jphi];
15607  ++nsumreconoiseHB3;
15608  }
15609  } // phi
15610  // PHI normalization :
15611  for (int jphi = 0; jphi < njphi; jphi++) {
15612  if (sumreconoiseHB0 != 0.)
15613  reconoisevarianceHB[0][jeta][jphi] /= (sumreconoiseHB0 / nsumreconoiseHB0);
15614  if (sumreconoiseHB1 != 0.)
15615  reconoisevarianceHB[1][jeta][jphi] /= (sumreconoiseHB1 / nsumreconoiseHB1);
15616  if (sumreconoiseHB2 != 0.)
15617  reconoisevarianceHB[2][jeta][jphi] /= (sumreconoiseHB2 / nsumreconoiseHB2);
15618  if (sumreconoiseHB3 != 0.)
15619  reconoisevarianceHB[3][jeta][jphi] /= (sumreconoiseHB3 / nsumreconoiseHB3);
15620  } // phi
15621  // reconoisevarianceHB (D) = sum(R*R)/N - (sum(R)/N)**2
15622  for (int jphi = 0; jphi < njphi; jphi++) {
15623  // cout<<"12 12 12 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
15624  reconoisevarianceHB[0][jeta][jphi] -= areconoiseHB[0][jeta][jphi] * areconoiseHB[0][jeta][jphi];
15625  reconoisevarianceHB[0][jeta][jphi] = fabs(reconoisevarianceHB[0][jeta][jphi]);
15626  reconoisevarianceHB[1][jeta][jphi] -= areconoiseHB[1][jeta][jphi] * areconoiseHB[1][jeta][jphi];
15627  reconoisevarianceHB[1][jeta][jphi] = fabs(reconoisevarianceHB[1][jeta][jphi]);
15628  reconoisevarianceHB[2][jeta][jphi] -= areconoiseHB[2][jeta][jphi] * areconoiseHB[2][jeta][jphi];
15629  reconoisevarianceHB[2][jeta][jphi] = fabs(reconoisevarianceHB[2][jeta][jphi]);
15630  reconoisevarianceHB[3][jeta][jphi] -= areconoiseHB[3][jeta][jphi] * areconoiseHB[3][jeta][jphi];
15631  reconoisevarianceHB[3][jeta][jphi] = fabs(reconoisevarianceHB[3][jeta][jphi]);
15632  }
15633  }
15634  }
15635  //cout<<" Vaiance: DONE*****" <<endl;
15636  //------------------------ 2D-eta/phi-plot: D, averaged over depthfs
15637  //======================================================================
15638  //======================================================================
15639  //cout<<" R2D-eta/phi-plot: D, averaged over depthfs *****" <<endl;
15640  c1x1->Clear();
15642  c1x0->Divide(1, 1);
15643  c1x0->cd(1);
15644  TH2F *DefzDreconoiseHB42D = new TH2F("DefzDreconoiseHB42D", "", neta, -41., 41., nphi, 0., 72.);
15645  TH2F *DefzDreconoiseHB42D0 = new TH2F("DefzDreconoiseHB42D0", "", neta, -41., 41., nphi, 0., 72.);
15646  TH2F *DefzDreconoiseHB42DF = (TH2F *)DefzDreconoiseHB42D0->Clone("DefzDreconoiseHB42DF");
15647  for (int i = 0; i < ndepth; i++) {
15648  for (int jeta = 0; jeta < neta; jeta++) {
15649  if ((jeta - 41 >= -16 && jeta - 41 <= -1) || (jeta - 41 >= 0 && jeta - 41 <= 15)) {
15650  for (int jphi = 0; jphi < nphi; jphi++) {
15651  double ccc1 = reconoisevarianceHB[i][jeta][jphi];
15652  int k2plot = jeta - 41;
15653  int kkk = k2plot; //if(k2plot >0 kkk=k2plot+1; //-41 +41 !=0
15654  if (areconoiseHB[i][jeta][jphi] > 0.) {
15655  DefzDreconoiseHB42D->Fill(kkk, jphi, ccc1);
15656  DefzDreconoiseHB42D0->Fill(kkk, jphi, 1.);
15657  }
15658  }
15659  }
15660  }
15661  }
15662  DefzDreconoiseHB42DF->Divide(DefzDreconoiseHB42D, DefzDreconoiseHB42D0, 1, 1, "B"); // average A
15663  // DefzDreconoiseHB1->Sumw2();
15664  gPad->SetGridy();
15665  gPad->SetGridx(); // gPad->SetLogz();
15666  DefzDreconoiseHB42DF->SetMarkerStyle(20);
15667  DefzDreconoiseHB42DF->SetMarkerSize(0.4);
15668  DefzDreconoiseHB42DF->GetZaxis()->SetLabelSize(0.08);
15669  DefzDreconoiseHB42DF->SetXTitle("<D>_depth #eta \b");
15670  DefzDreconoiseHB42DF->SetYTitle(" #phi \b");
15671  DefzDreconoiseHB42DF->SetZTitle("<D>_depth \b");
15672  DefzDreconoiseHB42DF->SetMarkerColor(2);
15673  DefzDreconoiseHB42DF->SetLineColor(
15674  0); // DefzDreconoiseHB42DF->SetMaximum(1.000); // DefzDreconoiseHB42DF->SetMinimum(1.0);
15675  DefzDreconoiseHB42DF->Draw("COLZ");
15677  c1x0->Update();
15678  c1x0->Print("DreconoiseGeneralD2PhiSymmetryHB.png");
15679  c1x0->Clear();
15680  // clean-up
15681  if (DefzDreconoiseHB42D)
15682  delete DefzDreconoiseHB42D;
15683  if (DefzDreconoiseHB42D0)
15684  delete DefzDreconoiseHB42D0;
15685  if (DefzDreconoiseHB42DF)
15686  delete DefzDreconoiseHB42DF;
15687  //====================================================================== 1D plot: D vs phi , averaged over depthfs & eta
15688  //======================================================================
15689  //cout<<" 1D plot: D vs phi , averaged over depthfs & eta *****" <<endl;
15690  c1x1->Clear();
15692  c1x1->Divide(1, 1);
15693  c1x1->cd(1);
15694  TH1F *DefzDreconoiseHB41D = new TH1F("DefzDreconoiseHB41D", "", nphi, 0., 72.);
15695  TH1F *DefzDreconoiseHB41D0 = new TH1F("DefzDreconoiseHB41D0", "", nphi, 0., 72.);
15696  TH1F *DefzDreconoiseHB41DF = (TH1F *)DefzDreconoiseHB41D0->Clone("DefzDreconoiseHB41DF");
15697 
15698  for (int jphi = 0; jphi < nphi; jphi++) {
15699  for (int jeta = 0; jeta < neta; jeta++) {
15700  if ((jeta - 41 >= -16 && jeta - 41 <= -1) || (jeta - 41 >= 0 && jeta - 41 <= 15)) {
15701  for (int i = 0; i < ndepth; i++) {
15702  double ccc1 = reconoisevarianceHB[i][jeta][jphi];
15703  if (areconoiseHB[i][jeta][jphi] > 0.) {
15704  DefzDreconoiseHB41D->Fill(jphi, ccc1);
15705  DefzDreconoiseHB41D0->Fill(jphi, 1.);
15706  }
15707  }
15708  }
15709  }
15710  }
15711  // DefzDreconoiseHB41D->Sumw2();DefzDreconoiseHB41D0->Sumw2();
15712 
15713  DefzDreconoiseHB41DF->Divide(DefzDreconoiseHB41D, DefzDreconoiseHB41D0, 1, 1, "B"); // R averaged over depthfs & eta
15714  DefzDreconoiseHB41D0->Sumw2();
15715  // for (int jphi=1;jphi<73;jphi++) {DefzDreconoiseHB41DF->SetBinError(jphi,0.01);}
15716  gPad->SetGridy();
15717  gPad->SetGridx(); // gPad->SetLogz();
15718  DefzDreconoiseHB41DF->SetMarkerStyle(20);
15719  DefzDreconoiseHB41DF->SetMarkerSize(1.4);
15720  DefzDreconoiseHB41DF->GetZaxis()->SetLabelSize(0.08);
15721  DefzDreconoiseHB41DF->SetXTitle("#phi \b");
15722  DefzDreconoiseHB41DF->SetYTitle(" <D> \b");
15723  DefzDreconoiseHB41DF->SetZTitle("<D>_PHI - AllDepthfs \b");
15724  DefzDreconoiseHB41DF->SetMarkerColor(4);
15725  DefzDreconoiseHB41DF->SetLineColor(
15726  4); //DefzDreconoiseHB41DF->SetMinimum(0.8); DefzDreconoiseHB41DF->SetMinimum(-0.015);
15727  DefzDreconoiseHB41DF->Draw("Error");
15729  c1x1->Update();
15730  c1x1->Print("DreconoiseGeneralD1PhiSymmetryHB.png");
15731  c1x1->Clear();
15732  // clean-up
15733  if (DefzDreconoiseHB41D)
15734  delete DefzDreconoiseHB41D;
15735  if (DefzDreconoiseHB41D0)
15736  delete DefzDreconoiseHB41D0;
15737  if (DefzDreconoiseHB41DF)
15738  delete DefzDreconoiseHB41DF;
15739 
15740  //========================================================================================== 14
15741  //======================================================================
15742  //======================================================================1D plot: D vs phi , different eta, depth=1
15743  //cout<<" 1D plot: D vs phi , different eta, depth=1 *****" <<endl;
15744  c3x5->Clear();
15746  c3x5->Divide(4, 4);
15747  c3x5->cd(1);
15748  int kcountHBpositivedirectionReconoiseD1 = 1;
15749  TH1F *h2CeffHBpositivedirectionReconoiseD1 = new TH1F("h2CeffHBpositivedirectionReconoiseD1", "", nphi, 0., 72.);
15750 
15751  for (int jeta = 0; jeta < njeta; jeta++) {
15752  // positivedirectionReconoiseD:
15753  if (jeta - 41 >= 0 && jeta - 41 <= 15) {
15754  // for (int i=0;i<ndepth;i++) {
15755  // depth=1
15756  for (int i = 0; i < 1; i++) {
15757  TH1F *HBpositivedirectionReconoiseD1 = (TH1F *)h2CeffHBpositivedirectionReconoiseD1->Clone("twod1");
15758 
15759  float ccctest = 0; // to avoid empty massive elements
15760  for (int jphi = 0; jphi < nphi; jphi++) {
15761  double ccc1 = reconoisevarianceHB[i][jeta][jphi];
15762  if (areconoiseHB[i][jeta][jphi] > 0.) {
15763  HBpositivedirectionReconoiseD1->Fill(jphi, ccc1);
15764  ccctest = 1.; //HBpositivedirectionReconoiseD1->SetBinError(i,0.01);
15765  }
15766  } // for jphi
15767  if (ccctest > 0.) {
15768  //cout<<"1414 kcountHBpositivedirectionReconoiseD1 = "<<kcountHBpositivedirectionReconoiseD1 <<" jeta-41= "<< jeta-41 <<endl;
15769  c3x5->cd(kcountHBpositivedirectionReconoiseD1);
15770  HBpositivedirectionReconoiseD1->SetMarkerStyle(20);
15771  HBpositivedirectionReconoiseD1->SetMarkerSize(0.4);
15772  HBpositivedirectionReconoiseD1->GetYaxis()->SetLabelSize(0.04);
15773  HBpositivedirectionReconoiseD1->SetXTitle("HBpositivedirectionReconoiseD1 \b");
15774  HBpositivedirectionReconoiseD1->SetMarkerColor(2);
15775  HBpositivedirectionReconoiseD1->SetLineColor(0);
15776  gPad->SetGridy();
15777  gPad->SetGridx();
15778  // gPad->SetLogy();
15779  if (kcountHBpositivedirectionReconoiseD1 == 1)
15780  HBpositivedirectionReconoiseD1->SetXTitle("D for HB+ jeta = 0; depth = 1 \b");
15781  if (kcountHBpositivedirectionReconoiseD1 == 2)
15782  HBpositivedirectionReconoiseD1->SetXTitle("D for HB+ jeta = 1; depth = 1 \b");
15783  if (kcountHBpositivedirectionReconoiseD1 == 3)
15784  HBpositivedirectionReconoiseD1->SetXTitle("D for HB+ jeta = 2; depth = 1 \b");
15785  if (kcountHBpositivedirectionReconoiseD1 == 4)
15786  HBpositivedirectionReconoiseD1->SetXTitle("D for HB+ jeta = 3; depth = 1 \b");
15787  if (kcountHBpositivedirectionReconoiseD1 == 5)
15788  HBpositivedirectionReconoiseD1->SetXTitle("D for HB+ jeta = 4; depth = 1 \b");
15789  if (kcountHBpositivedirectionReconoiseD1 == 6)
15790  HBpositivedirectionReconoiseD1->SetXTitle("D for HB+ jeta = 5; depth = 1 \b");
15791  if (kcountHBpositivedirectionReconoiseD1 == 7)
15792  HBpositivedirectionReconoiseD1->SetXTitle("D for HB+ jeta = 6; depth = 1 \b");
15793  if (kcountHBpositivedirectionReconoiseD1 == 8)
15794  HBpositivedirectionReconoiseD1->SetXTitle("D for HB+ jeta = 7; depth = 1 \b");
15795  if (kcountHBpositivedirectionReconoiseD1 == 9)
15796  HBpositivedirectionReconoiseD1->SetXTitle("D for HB+ jeta = 8; depth = 1 \b");
15797  if (kcountHBpositivedirectionReconoiseD1 == 10)
15798  HBpositivedirectionReconoiseD1->SetXTitle("D for HB+ jeta = 9; depth = 1 \b");
15799  if (kcountHBpositivedirectionReconoiseD1 == 11)
15800  HBpositivedirectionReconoiseD1->SetXTitle("D for HB+ jeta = 10; depth = 1 \b");
15801  if (kcountHBpositivedirectionReconoiseD1 == 12)
15802  HBpositivedirectionReconoiseD1->SetXTitle("D for HB+ jeta = 11; depth = 1 \b");
15803  if (kcountHBpositivedirectionReconoiseD1 == 13)
15804  HBpositivedirectionReconoiseD1->SetXTitle("D for HB+ jeta = 12; depth = 1 \b");
15805  if (kcountHBpositivedirectionReconoiseD1 == 14)
15806  HBpositivedirectionReconoiseD1->SetXTitle("D for HB+ jeta = 13; depth = 1 \b");
15807  if (kcountHBpositivedirectionReconoiseD1 == 15)
15808  HBpositivedirectionReconoiseD1->SetXTitle("D for HB+ jeta = 14; depth = 1 \b");
15809  if (kcountHBpositivedirectionReconoiseD1 == 16)
15810  HBpositivedirectionReconoiseD1->SetXTitle("D for HB+ jeta = 15; depth = 1 \b");
15811  HBpositivedirectionReconoiseD1->Draw("Error");
15812  kcountHBpositivedirectionReconoiseD1++;
15813  if (kcountHBpositivedirectionReconoiseD1 > 16)
15814  break; // 4x6 = 24
15815  } //ccctest>0
15816 
15817  } // for i
15818  } //if(jeta-41 >= 0)
15819  } //for jeta
15821  c3x5->Update();
15822  c3x5->Print("DreconoisePositiveDirectionhistD1PhiSymmetryDepth1HB.png");
15823  c3x5->Clear();
15824  // clean-up
15825  if (h2CeffHBpositivedirectionReconoiseD1)
15826  delete h2CeffHBpositivedirectionReconoiseD1;
15827  //========================================================================================== 15
15828  //======================================================================
15829  //======================================================================1D plot: D vs phi , different eta, depth=2
15830  //cout<<" 1D plot: D vs phi , different eta, depth=2 *****" <<endl;
15831  c3x5->Clear();
15832  c3x5->Divide(4, 4);
15833  c3x5->cd(1);
15834  int kcountHBpositivedirectionReconoiseD2 = 1;
15835  TH1F *h2CeffHBpositivedirectionReconoiseD2 = new TH1F("h2CeffHBpositivedirectionReconoiseD2", "", nphi, 0., 72.);
15836 
15837  for (int jeta = 0; jeta < njeta; jeta++) {
15838  // positivedirectionReconoiseD:
15839  if (jeta - 41 >= 0 && jeta - 41 <= 15) {
15840  // for (int i=0;i<ndepth;i++) {
15841  // depth=2
15842  for (int i = 1; i < 2; i++) {
15843  TH1F *HBpositivedirectionReconoiseD2 = (TH1F *)h2CeffHBpositivedirectionReconoiseD2->Clone("twod1");
15844 
15845  float ccctest = 0; // to avoid empty massive elements
15846  for (int jphi = 0; jphi < nphi; jphi++) {
15847  double ccc1 = reconoisevarianceHB[i][jeta][jphi];
15848  if (areconoiseHB[i][jeta][jphi] > 0.) {
15849  HBpositivedirectionReconoiseD2->Fill(jphi, ccc1);
15850  ccctest = 1.; //HBpositivedirectionReconoiseD2->SetBinError(i,0.01);
15851  }
15852  } // for jphi
15853  if (ccctest > 0.) {
15854  //cout<<"1515 kcountHBpositivedirectionReconoiseD2 = "<<kcountHBpositivedirectionReconoiseD2 <<" jeta-41= "<< jeta-41 <<endl;
15855  c3x5->cd(kcountHBpositivedirectionReconoiseD2);
15856  HBpositivedirectionReconoiseD2->SetMarkerStyle(20);
15857  HBpositivedirectionReconoiseD2->SetMarkerSize(0.4);
15858  HBpositivedirectionReconoiseD2->GetYaxis()->SetLabelSize(0.04);
15859  HBpositivedirectionReconoiseD2->SetXTitle("HBpositivedirectionReconoiseD2 \b");
15860  HBpositivedirectionReconoiseD2->SetMarkerColor(2);
15861  HBpositivedirectionReconoiseD2->SetLineColor(0);
15862  gPad->SetGridy();
15863  gPad->SetGridx();
15864  // gPad->SetLogy();
15865  if (kcountHBpositivedirectionReconoiseD2 == 1)
15866  HBpositivedirectionReconoiseD2->SetXTitle("D for HB+ jeta = 0; depth = 2 \b");
15867  if (kcountHBpositivedirectionReconoiseD2 == 2)
15868  HBpositivedirectionReconoiseD2->SetXTitle("D for HB+ jeta = 1; depth = 2 \b");
15869  if (kcountHBpositivedirectionReconoiseD2 == 3)
15870  HBpositivedirectionReconoiseD2->SetXTitle("D for HB+ jeta = 2; depth = 2 \b");
15871  if (kcountHBpositivedirectionReconoiseD2 == 4)
15872  HBpositivedirectionReconoiseD2->SetXTitle("D for HB+ jeta = 3; depth = 2 \b");
15873  if (kcountHBpositivedirectionReconoiseD2 == 5)
15874  HBpositivedirectionReconoiseD2->SetXTitle("D for HB+ jeta = 4; depth = 2 \b");
15875  if (kcountHBpositivedirectionReconoiseD2 == 6)
15876  HBpositivedirectionReconoiseD2->SetXTitle("D for HB+ jeta = 5; depth = 2 \b");
15877  if (kcountHBpositivedirectionReconoiseD2 == 7)
15878  HBpositivedirectionReconoiseD2->SetXTitle("D for HB+ jeta = 6; depth = 2 \b");
15879  if (kcountHBpositivedirectionReconoiseD2 == 8)
15880  HBpositivedirectionReconoiseD2->SetXTitle("D for HB+ jeta = 7; depth = 2 \b");
15881  if (kcountHBpositivedirectionReconoiseD2 == 9)
15882  HBpositivedirectionReconoiseD2->SetXTitle("D for HB+ jeta = 8; depth = 2 \b");
15883  if (kcountHBpositivedirectionReconoiseD2 == 10)
15884  HBpositivedirectionReconoiseD2->SetXTitle("D for HB+ jeta = 9; depth = 2 \b");
15885  if (kcountHBpositivedirectionReconoiseD2 == 11)
15886  HBpositivedirectionReconoiseD2->SetXTitle("D for HB+ jeta = 10; depth = 2 \b");
15887  if (kcountHBpositivedirectionReconoiseD2 == 12)
15888  HBpositivedirectionReconoiseD2->SetXTitle("D for HB+ jeta = 11; depth = 2 \b");
15889  if (kcountHBpositivedirectionReconoiseD2 == 13)
15890  HBpositivedirectionReconoiseD2->SetXTitle("D for HB+ jeta = 12; depth = 2 \b");
15891  if (kcountHBpositivedirectionReconoiseD2 == 14)
15892  HBpositivedirectionReconoiseD2->SetXTitle("D for HB+ jeta = 13; depth = 2 \b");
15893  if (kcountHBpositivedirectionReconoiseD2 == 15)
15894  HBpositivedirectionReconoiseD2->SetXTitle("D for HB+ jeta = 14; depth = 2 \b");
15895  if (kcountHBpositivedirectionReconoiseD2 == 16)
15896  HBpositivedirectionReconoiseD2->SetXTitle("D for HB+ jeta = 15; depth = 2 \b");
15897  HBpositivedirectionReconoiseD2->Draw("Error");
15898  kcountHBpositivedirectionReconoiseD2++;
15899  if (kcountHBpositivedirectionReconoiseD2 > 16)
15900  break; // 4x6 = 24
15901  } //ccctest>0
15902 
15903  } // for i
15904  } //if(jeta-41 >= 0)
15905  } //for jeta
15907  c3x5->Update();
15908  c3x5->Print("DreconoisePositiveDirectionhistD1PhiSymmetryDepth2HB.png");
15909  c3x5->Clear();
15910  // clean-up
15911  if (h2CeffHBpositivedirectionReconoiseD2)
15912  delete h2CeffHBpositivedirectionReconoiseD2;
15913  //========================================================================================== 16
15914  //======================================================================
15915  //======================================================================1D plot: D vs phi , different eta, depth=3
15916  //cout<<" 1D plot: D vs phi , different eta, depth=3 *****" <<endl;
15917  c3x5->Clear();
15918  c3x5->Divide(4, 4);
15919  c3x5->cd(1);
15920  int kcountHBpositivedirectionReconoiseD3 = 1;
15921  TH1F *h2CeffHBpositivedirectionReconoiseD3 = new TH1F("h2CeffHBpositivedirectionReconoiseD3", "", nphi, 0., 72.);
15922 
15923  for (int jeta = 0; jeta < njeta; jeta++) {
15924  // positivedirectionReconoiseD:
15925  if (jeta - 41 >= 0 && jeta - 41 <= 15) {
15926  // for (int i=0;i<ndepth;i++) {
15927  // depth=3
15928  for (int i = 2; i < 3; i++) {
15929  TH1F *HBpositivedirectionReconoiseD3 = (TH1F *)h2CeffHBpositivedirectionReconoiseD3->Clone("twod1");
15930 
15931  float ccctest = 0; // to avoid empty massive elements
15932  for (int jphi = 0; jphi < nphi; jphi++) {
15933  double ccc1 = reconoisevarianceHB[i][jeta][jphi];
15934  if (areconoiseHB[i][jeta][jphi] > 0.) {
15935  HBpositivedirectionReconoiseD3->Fill(jphi, ccc1);
15936  ccctest = 1.; //HBpositivedirectionReconoiseD3->SetBinError(i,0.01);
15937  }
15938  } // for jphi
15939  if (ccctest > 0.) {
15940  //cout<<"1616 kcountHBpositivedirectionReconoiseD3 = "<<kcountHBpositivedirectionReconoiseD3 <<" jeta-41= "<< jeta-41 <<endl;
15941  c3x5->cd(kcountHBpositivedirectionReconoiseD3);
15942  HBpositivedirectionReconoiseD3->SetMarkerStyle(20);
15943  HBpositivedirectionReconoiseD3->SetMarkerSize(0.4);
15944  HBpositivedirectionReconoiseD3->GetYaxis()->SetLabelSize(0.04);
15945  HBpositivedirectionReconoiseD3->SetXTitle("HBpositivedirectionReconoiseD3 \b");
15946  HBpositivedirectionReconoiseD3->SetMarkerColor(2);
15947  HBpositivedirectionReconoiseD3->SetLineColor(0);
15948  gPad->SetGridy();
15949  gPad->SetGridx();
15950  // gPad->SetLogy();
15951  if (kcountHBpositivedirectionReconoiseD3 == 1)
15952  HBpositivedirectionReconoiseD3->SetXTitle("D for HB+ jeta = 0; depth = 3 \b");
15953  if (kcountHBpositivedirectionReconoiseD3 == 2)
15954  HBpositivedirectionReconoiseD3->SetXTitle("D for HB+ jeta = 1; depth = 3 \b");
15955  if (kcountHBpositivedirectionReconoiseD3 == 3)
15956  HBpositivedirectionReconoiseD3->SetXTitle("D for HB+ jeta = 2; depth = 3 \b");
15957  if (kcountHBpositivedirectionReconoiseD3 == 4)
15958  HBpositivedirectionReconoiseD3->SetXTitle("D for HB+ jeta = 3; depth = 3 \b");
15959  if (kcountHBpositivedirectionReconoiseD3 == 5)
15960  HBpositivedirectionReconoiseD3->SetXTitle("D for HB+ jeta = 4; depth = 3 \b");
15961  if (kcountHBpositivedirectionReconoiseD3 == 6)
15962  HBpositivedirectionReconoiseD3->SetXTitle("D for HB+ jeta = 5; depth = 3 \b");
15963  if (kcountHBpositivedirectionReconoiseD3 == 7)
15964  HBpositivedirectionReconoiseD3->SetXTitle("D for HB+ jeta = 6; depth = 3 \b");
15965  if (kcountHBpositivedirectionReconoiseD3 == 8)
15966  HBpositivedirectionReconoiseD3->SetXTitle("D for HB+ jeta = 7; depth = 3 \b");
15967  if (kcountHBpositivedirectionReconoiseD3 == 9)
15968  HBpositivedirectionReconoiseD3->SetXTitle("D for HB+ jeta = 8; depth = 3 \b");
15969  if (kcountHBpositivedirectionReconoiseD3 == 10)
15970  HBpositivedirectionReconoiseD3->SetXTitle("D for HB+ jeta = 9; depth = 3 \b");
15971  if (kcountHBpositivedirectionReconoiseD3 == 11)
15972  HBpositivedirectionReconoiseD3->SetXTitle("D for HB+ jeta = 10; depth = 3 \b");
15973  if (kcountHBpositivedirectionReconoiseD3 == 12)
15974  HBpositivedirectionReconoiseD3->SetXTitle("D for HB+ jeta = 11; depth = 3 \b");
15975  if (kcountHBpositivedirectionReconoiseD3 == 13)
15976  HBpositivedirectionReconoiseD3->SetXTitle("D for HB+ jeta = 12; depth = 3 \b");
15977  if (kcountHBpositivedirectionReconoiseD3 == 14)
15978  HBpositivedirectionReconoiseD3->SetXTitle("D for HB+ jeta = 13; depth = 3 \b");
15979  if (kcountHBpositivedirectionReconoiseD3 == 15)
15980  HBpositivedirectionReconoiseD3->SetXTitle("D for HB+ jeta = 14; depth = 3 \b");
15981  if (kcountHBpositivedirectionReconoiseD3 == 16)
15982  HBpositivedirectionReconoiseD3->SetXTitle("D for HB+ jeta = 15; depth = 3 \b");
15983  HBpositivedirectionReconoiseD3->Draw("Error");
15984  kcountHBpositivedirectionReconoiseD3++;
15985  if (kcountHBpositivedirectionReconoiseD3 > 16)
15986  break; // 4x6 = 24
15987  } //ccctest>0
15988 
15989  } // for i
15990  } //if(jeta-41 >= 0)
15991  } //for jeta
15993  c3x5->Update();
15994  c3x5->Print("DreconoisePositiveDirectionhistD1PhiSymmetryDepth3HB.png");
15995  c3x5->Clear();
15996  // clean-up
15997  if (h2CeffHBpositivedirectionReconoiseD3)
15998  delete h2CeffHBpositivedirectionReconoiseD3;
15999  //========================================================================================== 17
16000  //======================================================================
16001  //======================================================================1D plot: D vs phi , different eta, depth=4
16002  //cout<<" 1D plot: D vs phi , different eta, depth=4 *****" <<endl;
16003  c3x5->Clear();
16004  c3x5->Divide(4, 4);
16005  c3x5->cd(1);
16006  int kcountHBpositivedirectionReconoiseD4 = 1;
16007  TH1F *h2CeffHBpositivedirectionReconoiseD4 = new TH1F("h2CeffHBpositivedirectionReconoiseD4", "", nphi, 0., 72.);
16008 
16009  for (int jeta = 0; jeta < njeta; jeta++) {
16010  // positivedirectionReconoiseD:
16011  if (jeta - 41 >= 0 && jeta - 41 <= 15) {
16012  // for (int i=0;i<ndepth;i++) {
16013  // depth=4
16014  for (int i = 3; i < 4; i++) {
16015  TH1F *HBpositivedirectionReconoiseD4 = (TH1F *)h2CeffHBpositivedirectionReconoiseD4->Clone("twod1");
16016 
16017  float ccctest = 0; // to avoid empty massive elements
16018  for (int jphi = 0; jphi < nphi; jphi++) {
16019  double ccc1 = reconoisevarianceHB[i][jeta][jphi];
16020  if (areconoiseHB[i][jeta][jphi] > 0.) {
16021  HBpositivedirectionReconoiseD4->Fill(jphi, ccc1);
16022  ccctest = 1.; //HBpositivedirectionReconoiseD4->SetBinError(i,0.01);
16023  }
16024  } // for jphi
16025  if (ccctest > 0.) {
16026  //cout<<"1717 kcountHBpositivedirectionReconoiseD4 = "<<kcountHBpositivedirectionReconoiseD4 <<" jeta-41= "<< jeta-41 <<endl;
16027  c3x5->cd(kcountHBpositivedirectionReconoiseD4);
16028  HBpositivedirectionReconoiseD4->SetMarkerStyle(20);
16029  HBpositivedirectionReconoiseD4->SetMarkerSize(0.4);
16030  HBpositivedirectionReconoiseD4->GetYaxis()->SetLabelSize(0.04);
16031  HBpositivedirectionReconoiseD4->SetXTitle("HBpositivedirectionReconoiseD4 \b");
16032  HBpositivedirectionReconoiseD4->SetMarkerColor(2);
16033  HBpositivedirectionReconoiseD4->SetLineColor(0);
16034  gPad->SetGridy();
16035  gPad->SetGridx();
16036  // gPad->SetLogy();
16037  if (kcountHBpositivedirectionReconoiseD4 == 1)
16038  HBpositivedirectionReconoiseD4->SetXTitle("D for HB+ jeta = 0; depth = 4 \b");
16039  if (kcountHBpositivedirectionReconoiseD4 == 2)
16040  HBpositivedirectionReconoiseD4->SetXTitle("D for HB+ jeta = 1; depth = 4 \b");
16041  if (kcountHBpositivedirectionReconoiseD4 == 3)
16042  HBpositivedirectionReconoiseD4->SetXTitle("D for HB+ jeta = 2; depth = 4 \b");
16043  if (kcountHBpositivedirectionReconoiseD4 == 4)
16044  HBpositivedirectionReconoiseD4->SetXTitle("D for HB+ jeta = 3; depth = 4 \b");
16045  if (kcountHBpositivedirectionReconoiseD4 == 5)
16046  HBpositivedirectionReconoiseD4->SetXTitle("D for HB+ jeta = 4; depth = 4 \b");
16047  if (kcountHBpositivedirectionReconoiseD4 == 6)
16048  HBpositivedirectionReconoiseD4->SetXTitle("D for HB+ jeta = 5; depth = 4 \b");
16049  if (kcountHBpositivedirectionReconoiseD4 == 7)
16050  HBpositivedirectionReconoiseD4->SetXTitle("D for HB+ jeta = 6; depth = 4 \b");
16051  if (kcountHBpositivedirectionReconoiseD4 == 8)
16052  HBpositivedirectionReconoiseD4->SetXTitle("D for HB+ jeta = 7; depth = 4 \b");
16053  if (kcountHBpositivedirectionReconoiseD4 == 9)
16054  HBpositivedirectionReconoiseD4->SetXTitle("D for HB+ jeta = 8; depth = 4 \b");
16055  if (kcountHBpositivedirectionReconoiseD4 == 10)
16056  HBpositivedirectionReconoiseD4->SetXTitle("D for HB+ jeta = 9; depth = 4 \b");
16057  if (kcountHBpositivedirectionReconoiseD4 == 11)
16058  HBpositivedirectionReconoiseD4->SetXTitle("D for HB+ jeta = 10; depth = 4 \b");
16059  if (kcountHBpositivedirectionReconoiseD4 == 12)
16060  HBpositivedirectionReconoiseD4->SetXTitle("D for HB+ jeta = 11; depth = 4 \b");
16061  if (kcountHBpositivedirectionReconoiseD4 == 13)
16062  HBpositivedirectionReconoiseD4->SetXTitle("D for HB+ jeta = 12; depth = 4 \b");
16063  if (kcountHBpositivedirectionReconoiseD4 == 14)
16064  HBpositivedirectionReconoiseD4->SetXTitle("D for HB+ jeta = 13; depth = 4 \b");
16065  if (kcountHBpositivedirectionReconoiseD4 == 15)
16066  HBpositivedirectionReconoiseD4->SetXTitle("D for HB+ jeta = 14; depth = 4 \b");
16067  if (kcountHBpositivedirectionReconoiseD4 == 16)
16068  HBpositivedirectionReconoiseD4->SetXTitle("D for HB+ jeta = 15; depth = 4 \b");
16069  HBpositivedirectionReconoiseD4->Draw("Error");
16070  kcountHBpositivedirectionReconoiseD4++;
16071  if (kcountHBpositivedirectionReconoiseD4 > 16)
16072  break; // 4x6 = 24
16073  } //ccctest>0
16074 
16075  } // for i
16076  } //if(jeta-41 >= 0)
16077  } //for jeta
16079  c3x5->Update();
16080  c3x5->Print("DreconoisePositiveDirectionhistD1PhiSymmetryDepth4HB.png");
16081  c3x5->Clear();
16082  // clean-up
16083  if (h2CeffHBpositivedirectionReconoiseD4)
16084  delete h2CeffHBpositivedirectionReconoiseD4;
16085 
16086  //========================================================================================== 22214
16087  //======================================================================
16088  //======================================================================1D plot: D vs phi , different eta, depth=1
16089  //cout<<" 1D plot: D vs phi , different eta, depth=1 *****" <<endl;
16090  c3x5->Clear();
16092  c3x5->Divide(4, 4);
16093  c3x5->cd(1);
16094  int kcountHBnegativedirectionReconoiseD1 = 1;
16095  TH1F *h2CeffHBnegativedirectionReconoiseD1 = new TH1F("h2CeffHBnegativedirectionReconoiseD1", "", nphi, 0., 72.);
16096 
16097  for (int jeta = 0; jeta < njeta; jeta++) {
16098  // negativedirectionReconoiseD:
16099  if (jeta - 41 >= -16 && jeta - 41 <= -1) {
16100  // for (int i=0;i<ndepth;i++) {
16101  // depth=1
16102  for (int i = 0; i < 1; i++) {
16103  TH1F *HBnegativedirectionReconoiseD1 = (TH1F *)h2CeffHBnegativedirectionReconoiseD1->Clone("twod1");
16104 
16105  float ccctest = 0; // to avoid empty massive elements
16106  for (int jphi = 0; jphi < nphi; jphi++) {
16107  double ccc1 = reconoisevarianceHB[i][jeta][jphi];
16108  if (areconoiseHB[i][jeta][jphi] > 0.) {
16109  HBnegativedirectionReconoiseD1->Fill(jphi, ccc1);
16110  ccctest = 1.; //HBnegativedirectionReconoiseD1->SetBinError(i,0.01);
16111  }
16112  } // for jphi
16113  if (ccctest > 0.) {
16114  //cout<<"1414 kcountHBnegativedirectionReconoiseD1 = "<<kcountHBnegativedirectionReconoiseD1 <<" jeta-41= "<< jeta-41 <<endl;
16115  c3x5->cd(kcountHBnegativedirectionReconoiseD1);
16116  HBnegativedirectionReconoiseD1->SetMarkerStyle(20);
16117  HBnegativedirectionReconoiseD1->SetMarkerSize(0.4);
16118  HBnegativedirectionReconoiseD1->GetYaxis()->SetLabelSize(0.04);
16119  HBnegativedirectionReconoiseD1->SetXTitle("HBnegativedirectionReconoiseD1 \b");
16120  HBnegativedirectionReconoiseD1->SetMarkerColor(2);
16121  HBnegativedirectionReconoiseD1->SetLineColor(0);
16122  gPad->SetGridy();
16123  gPad->SetGridx();
16124  // gPad->SetLogy();
16125  if (kcountHBnegativedirectionReconoiseD1 == 1)
16126  HBnegativedirectionReconoiseD1->SetXTitle("D for HB- jeta =-16; depth = 1 \b");
16127  if (kcountHBnegativedirectionReconoiseD1 == 2)
16128  HBnegativedirectionReconoiseD1->SetXTitle("D for HB- jeta =-15; depth = 1 \b");
16129  if (kcountHBnegativedirectionReconoiseD1 == 3)
16130  HBnegativedirectionReconoiseD1->SetXTitle("D for HB- jeta =-14; depth = 1 \b");
16131  if (kcountHBnegativedirectionReconoiseD1 == 4)
16132  HBnegativedirectionReconoiseD1->SetXTitle("D for HB- jeta =-13; depth = 1 \b");
16133  if (kcountHBnegativedirectionReconoiseD1 == 5)
16134  HBnegativedirectionReconoiseD1->SetXTitle("D for HB- jeta =-12; depth = 1 \b");
16135  if (kcountHBnegativedirectionReconoiseD1 == 6)
16136  HBnegativedirectionReconoiseD1->SetXTitle("D for HB- jeta =-11; depth = 1 \b");
16137  if (kcountHBnegativedirectionReconoiseD1 == 7)
16138  HBnegativedirectionReconoiseD1->SetXTitle("D for HB- jeta =-10; depth = 1 \b");
16139  if (kcountHBnegativedirectionReconoiseD1 == 8)
16140  HBnegativedirectionReconoiseD1->SetXTitle("D for HB- jeta =-9; depth = 1 \b");
16141  if (kcountHBnegativedirectionReconoiseD1 == 9)
16142  HBnegativedirectionReconoiseD1->SetXTitle("D for HB- jeta =-8; depth = 1 \b");
16143  if (kcountHBnegativedirectionReconoiseD1 == 10)
16144  HBnegativedirectionReconoiseD1->SetXTitle("D for HB- jeta =-7; depth = 1 \b");
16145  if (kcountHBnegativedirectionReconoiseD1 == 11)
16146  HBnegativedirectionReconoiseD1->SetXTitle("D for HB- jeta =-6; depth = 1 \b");
16147  if (kcountHBnegativedirectionReconoiseD1 == 12)
16148  HBnegativedirectionReconoiseD1->SetXTitle("D for HB- jeta =-5; depth = 1 \b");
16149  if (kcountHBnegativedirectionReconoiseD1 == 13)
16150  HBnegativedirectionReconoiseD1->SetXTitle("D for HB- jeta =-4; depth = 1 \b");
16151  if (kcountHBnegativedirectionReconoiseD1 == 14)
16152  HBnegativedirectionReconoiseD1->SetXTitle("D for HB- jeta =-3; depth = 1 \b");
16153  if (kcountHBnegativedirectionReconoiseD1 == 15)
16154  HBnegativedirectionReconoiseD1->SetXTitle("D for HB- jeta =-2; depth = 1 \b");
16155  if (kcountHBnegativedirectionReconoiseD1 == 16)
16156  HBnegativedirectionReconoiseD1->SetXTitle("D for HB- jeta =-1; depth = 1 \b");
16157  HBnegativedirectionReconoiseD1->Draw("Error");
16158  kcountHBnegativedirectionReconoiseD1++;
16159  if (kcountHBnegativedirectionReconoiseD1 > 16)
16160  break; // 4x6 = 24
16161  } //ccctest>0
16162 
16163  } // for i
16164  } //if(jeta-41 < 0)
16165  } //for jeta
16167  c3x5->Update();
16168  c3x5->Print("DreconoiseNegativeDirectionhistD1PhiSymmetryDepth1HB.png");
16169  c3x5->Clear();
16170  // clean-up
16171  if (h2CeffHBnegativedirectionReconoiseD1)
16172  delete h2CeffHBnegativedirectionReconoiseD1;
16173  //========================================================================================== 22215
16174  //======================================================================
16175  //======================================================================1D plot: D vs phi , different eta, depth=2
16176  //cout<<" 1D plot: D vs phi , different eta, depth=2 *****" <<endl;
16177  c3x5->Clear();
16178  c3x5->Divide(4, 4);
16179  c3x5->cd(1);
16180  int kcountHBnegativedirectionReconoiseD2 = 1;
16181  TH1F *h2CeffHBnegativedirectionReconoiseD2 = new TH1F("h2CeffHBnegativedirectionReconoiseD2", "", nphi, 0., 72.);
16182 
16183  for (int jeta = 0; jeta < njeta; jeta++) {
16184  // negativedirectionReconoiseD:
16185  if (jeta - 41 >= -16 && jeta - 41 <= -1) {
16186  // for (int i=0;i<ndepth;i++) {
16187  // depth=2
16188  for (int i = 1; i < 2; i++) {
16189  TH1F *HBnegativedirectionReconoiseD2 = (TH1F *)h2CeffHBnegativedirectionReconoiseD2->Clone("twod1");
16190 
16191  float ccctest = 0; // to avoid empty massive elements
16192  for (int jphi = 0; jphi < nphi; jphi++) {
16193  double ccc1 = reconoisevarianceHB[i][jeta][jphi];
16194  if (areconoiseHB[i][jeta][jphi] > 0.) {
16195  HBnegativedirectionReconoiseD2->Fill(jphi, ccc1);
16196  ccctest = 1.; //HBnegativedirectionReconoiseD2->SetBinError(i,0.01);
16197  }
16198  } // for jphi
16199  if (ccctest > 0.) {
16200  //cout<<"1515 kcountHBnegativedirectionReconoiseD2 = "<<kcountHBnegativedirectionReconoiseD2 <<" jeta-41= "<< jeta-41 <<endl;
16201  c3x5->cd(kcountHBnegativedirectionReconoiseD2);
16202  HBnegativedirectionReconoiseD2->SetMarkerStyle(20);
16203  HBnegativedirectionReconoiseD2->SetMarkerSize(0.4);
16204  HBnegativedirectionReconoiseD2->GetYaxis()->SetLabelSize(0.04);
16205  HBnegativedirectionReconoiseD2->SetXTitle("HBnegativedirectionReconoiseD2 \b");
16206  HBnegativedirectionReconoiseD2->SetMarkerColor(2);
16207  HBnegativedirectionReconoiseD2->SetLineColor(0);
16208  gPad->SetGridy();
16209  gPad->SetGridx();
16210  // gPad->SetLogy();
16211  if (kcountHBnegativedirectionReconoiseD2 == 1)
16212  HBnegativedirectionReconoiseD2->SetXTitle("D for HB- jeta =-16; depth = 2 \b");
16213  if (kcountHBnegativedirectionReconoiseD2 == 2)
16214  HBnegativedirectionReconoiseD2->SetXTitle("D for HB- jeta =-15; depth = 2 \b");
16215  if (kcountHBnegativedirectionReconoiseD2 == 3)
16216  HBnegativedirectionReconoiseD2->SetXTitle("D for HB- jeta =-14; depth = 2 \b");
16217  if (kcountHBnegativedirectionReconoiseD2 == 4)
16218  HBnegativedirectionReconoiseD2->SetXTitle("D for HB- jeta =-13; depth = 2 \b");
16219  if (kcountHBnegativedirectionReconoiseD2 == 5)
16220  HBnegativedirectionReconoiseD2->SetXTitle("D for HB- jeta =-12; depth = 2 \b");
16221  if (kcountHBnegativedirectionReconoiseD2 == 6)
16222  HBnegativedirectionReconoiseD2->SetXTitle("D for HB- jeta =-11; depth = 2 \b");
16223  if (kcountHBnegativedirectionReconoiseD2 == 7)
16224  HBnegativedirectionReconoiseD2->SetXTitle("D for HB- jeta =-10; depth = 2 \b");
16225  if (kcountHBnegativedirectionReconoiseD2 == 8)
16226  HBnegativedirectionReconoiseD2->SetXTitle("D for HB- jeta =-9; depth = 2 \b");
16227  if (kcountHBnegativedirectionReconoiseD2 == 9)
16228  HBnegativedirectionReconoiseD2->SetXTitle("D for HB- jeta =-8; depth = 2 \b");
16229  if (kcountHBnegativedirectionReconoiseD2 == 10)
16230  HBnegativedirectionReconoiseD2->SetXTitle("D for HB- jeta =-7; depth = 2 \b");
16231  if (kcountHBnegativedirectionReconoiseD2 == 11)
16232  HBnegativedirectionReconoiseD2->SetXTitle("D for HB- jeta =-6; depth = 2 \b");
16233  if (kcountHBnegativedirectionReconoiseD2 == 12)
16234  HBnegativedirectionReconoiseD2->SetXTitle("D for HB- jeta =-5; depth = 2 \b");
16235  if (kcountHBnegativedirectionReconoiseD2 == 13)
16236  HBnegativedirectionReconoiseD2->SetXTitle("D for HB- jeta =-4; depth = 2 \b");
16237  if (kcountHBnegativedirectionReconoiseD2 == 14)
16238  HBnegativedirectionReconoiseD2->SetXTitle("D for HB- jeta =-3; depth = 2 \b");
16239  if (kcountHBnegativedirectionReconoiseD2 == 15)
16240  HBnegativedirectionReconoiseD2->SetXTitle("D for HB- jeta =-2; depth = 2 \b");
16241  if (kcountHBnegativedirectionReconoiseD2 == 16)
16242  HBnegativedirectionReconoiseD2->SetXTitle("D for HB- jeta =-1; depth = 2 \b");
16243  HBnegativedirectionReconoiseD2->Draw("Error");
16244  kcountHBnegativedirectionReconoiseD2++;
16245  if (kcountHBnegativedirectionReconoiseD2 > 16)
16246  break; // 4x6 = 24
16247  } //ccctest>0
16248 
16249  } // for i
16250  } //if(jeta-41 < 0)
16251  } //for jeta
16253  c3x5->Update();
16254  c3x5->Print("DreconoiseNegativeDirectionhistD1PhiSymmetryDepth2HB.png");
16255  c3x5->Clear();
16256  // clean-up
16257  if (h2CeffHBnegativedirectionReconoiseD2)
16258  delete h2CeffHBnegativedirectionReconoiseD2;
16259  //========================================================================================== 22216
16260  //======================================================================
16261  //======================================================================1D plot: D vs phi , different eta, depth=3
16262  //cout<<" 1D plot: D vs phi , different eta, depth=3 *****" <<endl;
16263  c3x5->Clear();
16264  c3x5->Divide(4, 4);
16265  c3x5->cd(1);
16266  int kcountHBnegativedirectionReconoiseD3 = 1;
16267  TH1F *h2CeffHBnegativedirectionReconoiseD3 = new TH1F("h2CeffHBnegativedirectionReconoiseD3", "", nphi, 0., 72.);
16268 
16269  for (int jeta = 0; jeta < njeta; jeta++) {
16270  // negativedirectionReconoiseD:
16271  if (jeta - 41 >= -16 && jeta - 41 <= -1) {
16272  // for (int i=0;i<ndepth;i++) {
16273  // depth=3
16274  for (int i = 2; i < 3; i++) {
16275  TH1F *HBnegativedirectionReconoiseD3 = (TH1F *)h2CeffHBnegativedirectionReconoiseD3->Clone("twod1");
16276 
16277  float ccctest = 0; // to avoid empty massive elements
16278  for (int jphi = 0; jphi < nphi; jphi++) {
16279  double ccc1 = reconoisevarianceHB[i][jeta][jphi];
16280  if (areconoiseHB[i][jeta][jphi] > 0.) {
16281  HBnegativedirectionReconoiseD3->Fill(jphi, ccc1);
16282  ccctest = 1.; //HBnegativedirectionReconoiseD3->SetBinError(i,0.01);
16283  }
16284  } // for jphi
16285  if (ccctest > 0.) {
16286  //cout<<"1616 kcountHBnegativedirectionReconoiseD3 = "<<kcountHBnegativedirectionReconoiseD3 <<" jeta-41= "<< jeta-41 <<endl;
16287  c3x5->cd(kcountHBnegativedirectionReconoiseD3);
16288  HBnegativedirectionReconoiseD3->SetMarkerStyle(20);
16289  HBnegativedirectionReconoiseD3->SetMarkerSize(0.4);
16290  HBnegativedirectionReconoiseD3->GetYaxis()->SetLabelSize(0.04);
16291  HBnegativedirectionReconoiseD3->SetXTitle("HBnegativedirectionReconoiseD3 \b");
16292  HBnegativedirectionReconoiseD3->SetMarkerColor(2);
16293  HBnegativedirectionReconoiseD3->SetLineColor(0);
16294  gPad->SetGridy();
16295  gPad->SetGridx();
16296  // gPad->SetLogy();
16297  if (kcountHBnegativedirectionReconoiseD3 == 1)
16298  HBnegativedirectionReconoiseD3->SetXTitle("D for HB- jeta =-16; depth = 3 \b");
16299  if (kcountHBnegativedirectionReconoiseD3 == 2)
16300  HBnegativedirectionReconoiseD3->SetXTitle("D for HB- jeta =-15; depth = 3 \b");
16301  if (kcountHBnegativedirectionReconoiseD3 == 3)
16302  HBnegativedirectionReconoiseD3->SetXTitle("D for HB- jeta =-14; depth = 3 \b");
16303  if (kcountHBnegativedirectionReconoiseD3 == 4)
16304  HBnegativedirectionReconoiseD3->SetXTitle("D for HB- jeta =-13; depth = 3 \b");
16305  if (kcountHBnegativedirectionReconoiseD3 == 5)
16306  HBnegativedirectionReconoiseD3->SetXTitle("D for HB- jeta =-12; depth = 3 \b");
16307  if (kcountHBnegativedirectionReconoiseD3 == 6)
16308  HBnegativedirectionReconoiseD3->SetXTitle("D for HB- jeta =-11; depth = 3 \b");
16309  if (kcountHBnegativedirectionReconoiseD3 == 7)
16310  HBnegativedirectionReconoiseD3->SetXTitle("D for HB- jeta =-10; depth = 3 \b");
16311  if (kcountHBnegativedirectionReconoiseD3 == 8)
16312  HBnegativedirectionReconoiseD3->SetXTitle("D for HB- jeta =-9; depth = 3 \b");
16313  if (kcountHBnegativedirectionReconoiseD3 == 9)
16314  HBnegativedirectionReconoiseD3->SetXTitle("D for HB- jeta =-8; depth = 3 \b");
16315  if (kcountHBnegativedirectionReconoiseD3 == 10)
16316  HBnegativedirectionReconoiseD3->SetXTitle("D for HB- jeta =-7; depth = 3 \b");
16317  if (kcountHBnegativedirectionReconoiseD3 == 11)
16318  HBnegativedirectionReconoiseD3->SetXTitle("D for HB- jeta =-6; depth = 3 \b");
16319  if (kcountHBnegativedirectionReconoiseD3 == 12)
16320  HBnegativedirectionReconoiseD3->SetXTitle("D for HB- jeta =-5; depth = 3 \b");
16321  if (kcountHBnegativedirectionReconoiseD3 == 13)
16322  HBnegativedirectionReconoiseD3->SetXTitle("D for HB- jeta =-4; depth = 3 \b");
16323  if (kcountHBnegativedirectionReconoiseD3 == 14)
16324  HBnegativedirectionReconoiseD3->SetXTitle("D for HB- jeta =-3; depth = 3 \b");
16325  if (kcountHBnegativedirectionReconoiseD3 == 15)
16326  HBnegativedirectionReconoiseD3->SetXTitle("D for HB- jeta =-2; depth = 3 \b");
16327  if (kcountHBnegativedirectionReconoiseD3 == 16)
16328  HBnegativedirectionReconoiseD3->SetXTitle("D for HB- jeta =-1; depth = 3 \b");
16329  HBnegativedirectionReconoiseD3->Draw("Error");
16330  kcountHBnegativedirectionReconoiseD3++;
16331  if (kcountHBnegativedirectionReconoiseD3 > 16)
16332  break; // 4x6 = 24
16333  } //ccctest>0
16334 
16335  } // for i
16336  } //if(jeta-41 < 0)
16337  } //for jeta
16339  c3x5->Update();
16340  c3x5->Print("DreconoiseNegativeDirectionhistD1PhiSymmetryDepth3HB.png");
16341  c3x5->Clear();
16342  // clean-up
16343  if (h2CeffHBnegativedirectionReconoiseD3)
16344  delete h2CeffHBnegativedirectionReconoiseD3;
16345  //========================================================================================== 22217
16346  //======================================================================
16347  //======================================================================1D plot: D vs phi , different eta, depth=4
16348  //cout<<" 1D plot: D vs phi , different eta, depth=4 *****" <<endl;
16349  c3x5->Clear();
16350  c3x5->Divide(4, 4);
16351  c3x5->cd(1);
16352  int kcountHBnegativedirectionReconoiseD4 = 1;
16353  TH1F *h2CeffHBnegativedirectionReconoiseD4 = new TH1F("h2CeffHBnegativedirectionReconoiseD4", "", nphi, 0., 72.);
16354 
16355  for (int jeta = 0; jeta < njeta; jeta++) {
16356  // negativedirectionReconoiseD:
16357  if (jeta - 41 >= -16 && jeta - 41 <= -1) {
16358  // for (int i=0;i<ndepth;i++) {
16359  // depth=4
16360  for (int i = 3; i < 4; i++) {
16361  TH1F *HBnegativedirectionReconoiseD4 = (TH1F *)h2CeffHBnegativedirectionReconoiseD4->Clone("twod1");
16362 
16363  float ccctest = 0; // to avoid empty massive elements
16364  for (int jphi = 0; jphi < nphi; jphi++) {
16365  double ccc1 = reconoisevarianceHB[i][jeta][jphi];
16366  if (areconoiseHB[i][jeta][jphi] > 0.) {
16367  HBnegativedirectionReconoiseD4->Fill(jphi, ccc1);
16368  ccctest = 1.; //HBnegativedirectionReconoiseD4->SetBinError(i,0.01);
16369  }
16370  } // for jphi
16371  if (ccctest > 0.) {
16372  //cout<<"1717 kcountHBnegativedirectionReconoiseD4 = "<<kcountHBnegativedirectionReconoiseD4 <<" jeta-41= "<< jeta-41 <<endl;
16373  c3x5->cd(kcountHBnegativedirectionReconoiseD4);
16374  HBnegativedirectionReconoiseD4->SetMarkerStyle(20);
16375  HBnegativedirectionReconoiseD4->SetMarkerSize(0.4);
16376  HBnegativedirectionReconoiseD4->GetYaxis()->SetLabelSize(0.04);
16377  HBnegativedirectionReconoiseD4->SetXTitle("HBnegativedirectionReconoiseD4 \b");
16378  HBnegativedirectionReconoiseD4->SetMarkerColor(2);
16379  HBnegativedirectionReconoiseD4->SetLineColor(0);
16380  gPad->SetGridy();
16381  gPad->SetGridx();
16382  // gPad->SetLogy();
16383  if (kcountHBnegativedirectionReconoiseD4 == 1)
16384  HBnegativedirectionReconoiseD4->SetXTitle("D for HB- jeta =-16; depth = 4 \b");
16385  if (kcountHBnegativedirectionReconoiseD4 == 2)
16386  HBnegativedirectionReconoiseD4->SetXTitle("D for HB- jeta =-15; depth = 4 \b");
16387  if (kcountHBnegativedirectionReconoiseD4 == 3)
16388  HBnegativedirectionReconoiseD4->SetXTitle("D for HB- jeta =-14; depth = 4 \b");
16389  if (kcountHBnegativedirectionReconoiseD4 == 4)
16390  HBnegativedirectionReconoiseD4->SetXTitle("D for HB- jeta =-13; depth = 4 \b");
16391  if (kcountHBnegativedirectionReconoiseD4 == 5)
16392  HBnegativedirectionReconoiseD4->SetXTitle("D for HB- jeta =-12; depth = 4 \b");
16393  if (kcountHBnegativedirectionReconoiseD4 == 6)
16394  HBnegativedirectionReconoiseD4->SetXTitle("D for HB- jeta =-11; depth = 4 \b");
16395  if (kcountHBnegativedirectionReconoiseD4 == 7)
16396  HBnegativedirectionReconoiseD4->SetXTitle("D for HB- jeta =-10; depth = 4 \b");
16397  if (kcountHBnegativedirectionReconoiseD4 == 8)
16398  HBnegativedirectionReconoiseD4->SetXTitle("D for HB- jeta =-9; depth = 4 \b");
16399  if (kcountHBnegativedirectionReconoiseD4 == 9)
16400  HBnegativedirectionReconoiseD4->SetXTitle("D for HB- jeta =-8; depth = 4 \b");
16401  if (kcountHBnegativedirectionReconoiseD4 == 10)
16402  HBnegativedirectionReconoiseD4->SetXTitle("D for HB- jeta =-7; depth = 4 \b");
16403  if (kcountHBnegativedirectionReconoiseD4 == 11)
16404  HBnegativedirectionReconoiseD4->SetXTitle("D for HB- jeta =-6; depth = 4 \b");
16405  if (kcountHBnegativedirectionReconoiseD4 == 12)
16406  HBnegativedirectionReconoiseD4->SetXTitle("D for HB- jeta =-5; depth = 4 \b");
16407  if (kcountHBnegativedirectionReconoiseD4 == 13)
16408  HBnegativedirectionReconoiseD4->SetXTitle("D for HB- jeta =-4; depth = 4 \b");
16409  if (kcountHBnegativedirectionReconoiseD4 == 14)
16410  HBnegativedirectionReconoiseD4->SetXTitle("D for HB- jeta =-3; depth = 4 \b");
16411  if (kcountHBnegativedirectionReconoiseD4 == 15)
16412  HBnegativedirectionReconoiseD4->SetXTitle("D for HB- jeta =-2; depth = 4 \b");
16413  if (kcountHBnegativedirectionReconoiseD4 == 16)
16414  HBnegativedirectionReconoiseD4->SetXTitle("D for HB- jeta =-1; depth = 4 \b");
16415  HBnegativedirectionReconoiseD4->Draw("Error");
16416  kcountHBnegativedirectionReconoiseD4++;
16417  if (kcountHBnegativedirectionReconoiseD4 > 16)
16418  break; // 4x6 = 24
16419  } //ccctest>0
16420 
16421  } // for i
16422  } //if(jeta-41 < 0)
16423  } //for jeta
16425  c3x5->Update();
16426  c3x5->Print("DreconoiseNegativeDirectionhistD1PhiSymmetryDepth4HB.png");
16427  c3x5->Clear();
16428  // clean-up
16429  if (h2CeffHBnegativedirectionReconoiseD4)
16430  delete h2CeffHBnegativedirectionReconoiseD4;
16431 
16432  //===================================================================== END of Reconoise HB for phi-symmetry
16433  //===================================================================== END of Reconoise HB for phi-symmetry
16434  //===================================================================== END of Reconoise HB for phi-symmetry
16435 
16439  // int k_max[5]={0,4,7,4,4}; // maximum depth for each subdet
16440  //ndepth = k_max[3];
16441  ndepth = 7;
16442  // const int ndepth = 7;
16443  double areconoisehe[ndepth][njeta][njphi];
16444  double breconoisehe[ndepth][njeta][njphi];
16445  double reconoisevariancehe[ndepth][njeta][njphi];
16447  TH2F *recNoiseEnergy1HE1 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy1_HE1");
16448  TH2F *recNoiseEnergy0HE1 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HE1");
16449  TH2F *recNoiseEnergyHE1 = (TH2F *)recNoiseEnergy1HE1->Clone("recNoiseEnergyHE1");
16450  recNoiseEnergyHE1->Divide(recNoiseEnergy1HE1, recNoiseEnergy0HE1, 1, 1, "B");
16451  TH2F *recNoiseEnergy1HE2 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy1_HE2");
16452  TH2F *recNoiseEnergy0HE2 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HE2");
16453  TH2F *recNoiseEnergyHE2 = (TH2F *)recNoiseEnergy1HE2->Clone("recNoiseEnergyHE2");
16454  recNoiseEnergyHE2->Divide(recNoiseEnergy1HE2, recNoiseEnergy0HE2, 1, 1, "B");
16455  TH2F *recNoiseEnergy1HE3 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy1_HE3");
16456  TH2F *recNoiseEnergy0HE3 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HE3");
16457  TH2F *recNoiseEnergyHE3 = (TH2F *)recNoiseEnergy1HE3->Clone("recNoiseEnergyHE3");
16458  recNoiseEnergyHE3->Divide(recNoiseEnergy1HE3, recNoiseEnergy0HE3, 1, 1, "B");
16459  TH2F *recNoiseEnergy1HE4 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy1_HE4");
16460  TH2F *recNoiseEnergy0HE4 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HE4");
16461  TH2F *recNoiseEnergyHE4 = (TH2F *)recNoiseEnergy1HE4->Clone("recNoiseEnergyHE4");
16462  recNoiseEnergyHE4->Divide(recNoiseEnergy1HE4, recNoiseEnergy0HE4, 1, 1, "B");
16463  TH2F *recNoiseEnergy1HE5 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy1_HE5");
16464  TH2F *recNoiseEnergy0HE5 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HE5");
16465  TH2F *recNoiseEnergyHE5 = (TH2F *)recNoiseEnergy1HE5->Clone("recNoiseEnergyHE5");
16466  recNoiseEnergyHE5->Divide(recNoiseEnergy1HE5, recNoiseEnergy0HE5, 1, 1, "B");
16467  TH2F *recNoiseEnergy1HE6 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy1_HE6");
16468  TH2F *recNoiseEnergy0HE6 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HE6");
16469  TH2F *recNoiseEnergyHE6 = (TH2F *)recNoiseEnergy1HE6->Clone("recNoiseEnergyHE6");
16470  recNoiseEnergyHE6->Divide(recNoiseEnergy1HE6, recNoiseEnergy0HE6, 1, 1, "B");
16471  TH2F *recNoiseEnergy1HE7 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy1_HE7");
16472  TH2F *recNoiseEnergy0HE7 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HE7");
16473  TH2F *recNoiseEnergyHE7 = (TH2F *)recNoiseEnergy1HE7->Clone("recNoiseEnergyHE7");
16474  recNoiseEnergyHE7->Divide(recNoiseEnergy1HE7, recNoiseEnergy0HE7, 1, 1, "B");
16475  for (int jeta = 0; jeta < njeta; jeta++) {
16476  if ((jeta - 41 >= -29 && jeta - 41 <= -16) || (jeta - 41 >= 15 && jeta - 41 <= 28)) {
16477  //====================================================================== PHI normalization & put R into massive areconoisehe
16478  //preparation for PHI normalization:
16479  double sumreconoiseHE0 = 0;
16480  int nsumreconoiseHE0 = 0;
16481  double sumreconoiseHE1 = 0;
16482  int nsumreconoiseHE1 = 0;
16483  double sumreconoiseHE2 = 0;
16484  int nsumreconoiseHE2 = 0;
16485  double sumreconoiseHE3 = 0;
16486  int nsumreconoiseHE3 = 0;
16487  double sumreconoiseHE4 = 0;
16488  int nsumreconoiseHE4 = 0;
16489  double sumreconoiseHE5 = 0;
16490  int nsumreconoiseHE5 = 0;
16491  double sumreconoiseHE6 = 0;
16492  int nsumreconoiseHE6 = 0;
16493  for (int jphi = 0; jphi < njphi; jphi++) {
16494  areconoisehe[0][jeta][jphi] = recNoiseEnergyHE1->GetBinContent(jeta + 1, jphi + 1);
16495  areconoisehe[1][jeta][jphi] = recNoiseEnergyHE2->GetBinContent(jeta + 1, jphi + 1);
16496  areconoisehe[2][jeta][jphi] = recNoiseEnergyHE3->GetBinContent(jeta + 1, jphi + 1);
16497  areconoisehe[3][jeta][jphi] = recNoiseEnergyHE4->GetBinContent(jeta + 1, jphi + 1);
16498  areconoisehe[4][jeta][jphi] = recNoiseEnergyHE5->GetBinContent(jeta + 1, jphi + 1);
16499  areconoisehe[5][jeta][jphi] = recNoiseEnergyHE6->GetBinContent(jeta + 1, jphi + 1);
16500  areconoisehe[6][jeta][jphi] = recNoiseEnergyHE7->GetBinContent(jeta + 1, jphi + 1);
16501 
16502  breconoisehe[0][jeta][jphi] = recNoiseEnergyHE1->GetBinContent(jeta + 1, jphi + 1);
16503  breconoisehe[1][jeta][jphi] = recNoiseEnergyHE2->GetBinContent(jeta + 1, jphi + 1);
16504  breconoisehe[2][jeta][jphi] = recNoiseEnergyHE3->GetBinContent(jeta + 1, jphi + 1);
16505  breconoisehe[3][jeta][jphi] = recNoiseEnergyHE4->GetBinContent(jeta + 1, jphi + 1);
16506  breconoisehe[4][jeta][jphi] = recNoiseEnergyHE5->GetBinContent(jeta + 1, jphi + 1);
16507  breconoisehe[5][jeta][jphi] = recNoiseEnergyHE6->GetBinContent(jeta + 1, jphi + 1);
16508  breconoisehe[6][jeta][jphi] = recNoiseEnergyHE7->GetBinContent(jeta + 1, jphi + 1);
16509 
16510  if (areconoisehe[0][jeta][jphi] != 0.) {
16511  sumreconoiseHE0 += areconoisehe[0][jeta][jphi];
16512  ++nsumreconoiseHE0;
16513  }
16514  if (areconoisehe[1][jeta][jphi] != 0.) {
16515  sumreconoiseHE1 += areconoisehe[1][jeta][jphi];
16516  ++nsumreconoiseHE1;
16517  }
16518  if (areconoisehe[2][jeta][jphi] != 0.) {
16519  sumreconoiseHE2 += areconoisehe[2][jeta][jphi];
16520  ++nsumreconoiseHE2;
16521  }
16522  if (areconoisehe[3][jeta][jphi] != 0.) {
16523  sumreconoiseHE3 += areconoisehe[3][jeta][jphi];
16524  ++nsumreconoiseHE3;
16525  }
16526  if (areconoisehe[4][jeta][jphi] != 0.) {
16527  sumreconoiseHE4 += areconoisehe[4][jeta][jphi];
16528  ++nsumreconoiseHE4;
16529  }
16530  if (areconoisehe[5][jeta][jphi] != 0.) {
16531  sumreconoiseHE5 += areconoisehe[5][jeta][jphi];
16532  ++nsumreconoiseHE5;
16533  }
16534  if (areconoisehe[6][jeta][jphi] != 0.) {
16535  sumreconoiseHE6 += areconoisehe[6][jeta][jphi];
16536  ++nsumreconoiseHE6;
16537  }
16538  } // phi
16539 
16540  // PHI normalization for DIF:
16541  for (int jphi = 0; jphi < njphi; jphi++) {
16542  if (sumreconoiseHE0 != 0.)
16543  breconoisehe[0][jeta][jphi] -= (sumreconoiseHE0 / nsumreconoiseHE0);
16544  if (sumreconoiseHE1 != 0.)
16545  breconoisehe[1][jeta][jphi] -= (sumreconoiseHE1 / nsumreconoiseHE1);
16546  if (sumreconoiseHE2 != 0.)
16547  breconoisehe[2][jeta][jphi] -= (sumreconoiseHE2 / nsumreconoiseHE2);
16548  if (sumreconoiseHE3 != 0.)
16549  breconoisehe[3][jeta][jphi] -= (sumreconoiseHE3 / nsumreconoiseHE3);
16550  if (sumreconoiseHE4 != 0.)
16551  breconoisehe[4][jeta][jphi] -= (sumreconoiseHE4 / nsumreconoiseHE4);
16552  if (sumreconoiseHE5 != 0.)
16553  breconoisehe[5][jeta][jphi] -= (sumreconoiseHE5 / nsumreconoiseHE5);
16554  if (sumreconoiseHE6 != 0.)
16555  breconoisehe[6][jeta][jphi] -= (sumreconoiseHE6 / nsumreconoiseHE6);
16556  } // phi
16557 
16558  // PHI normalization for R:
16559  for (int jphi = 0; jphi < njphi; jphi++) {
16560  if (sumreconoiseHE0 != 0.)
16561  areconoisehe[0][jeta][jphi] /= (sumreconoiseHE0 / nsumreconoiseHE0);
16562  if (sumreconoiseHE1 != 0.)
16563  areconoisehe[1][jeta][jphi] /= (sumreconoiseHE1 / nsumreconoiseHE1);
16564  if (sumreconoiseHE2 != 0.)
16565  areconoisehe[2][jeta][jphi] /= (sumreconoiseHE2 / nsumreconoiseHE2);
16566  if (sumreconoiseHE3 != 0.)
16567  areconoisehe[3][jeta][jphi] /= (sumreconoiseHE3 / nsumreconoiseHE3);
16568  if (sumreconoiseHE4 != 0.)
16569  areconoisehe[4][jeta][jphi] /= (sumreconoiseHE4 / nsumreconoiseHE4);
16570  if (sumreconoiseHE5 != 0.)
16571  areconoisehe[5][jeta][jphi] /= (sumreconoiseHE5 / nsumreconoiseHE5);
16572  if (sumreconoiseHE6 != 0.)
16573  areconoisehe[6][jeta][jphi] /= (sumreconoiseHE6 / nsumreconoiseHE6);
16574  } // phi
16575  } //if( (jeta-41 >=
16576  } //eta
16577  //------------------------ 2D-eta/phi-plot: R, averaged over depthes
16578  //======================================================================
16579  // RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR: Reconoise HE
16580  //======================================================================
16581  c2x1->Clear();
16583  c2x1->Divide(2, 1);
16584  c2x1->cd(1);
16585  TH2F *GefzRreconoiseHE42D = new TH2F("GefzRreconoiseHE42D", "", neta, -41., 41., nphi, 0., 72.);
16586  TH2F *GefzRreconoiseHE42D0 = new TH2F("GefzRreconoiseHE42D0", "", neta, -41., 41., nphi, 0., 72.);
16587  TH2F *GefzRreconoiseHE42DF = (TH2F *)GefzRreconoiseHE42D0->Clone("GefzRreconoiseHE42DF");
16588  for (int i = 0; i < ndepth; i++) {
16589  for (int jeta = 0; jeta < neta; jeta++) {
16590  if ((jeta - 41 >= -29 && jeta - 41 <= -16) || (jeta - 41 >= 15 && jeta - 41 <= 28)) {
16591  for (int jphi = 0; jphi < nphi; jphi++) {
16592  double ccc1 = areconoisehe[i][jeta][jphi];
16593  int k2plot = jeta - 41;
16594  int kkk = k2plot; //if(k2plot >0 ) kkk=k2plot+1; //-41 +41 !=0
16595  if (ccc1 != 0.) {
16596  GefzRreconoiseHE42D->Fill(kkk, jphi, ccc1);
16597  GefzRreconoiseHE42D0->Fill(kkk, jphi, 1.);
16598  }
16599  }
16600  }
16601  }
16602  }
16603  GefzRreconoiseHE42DF->Divide(GefzRreconoiseHE42D, GefzRreconoiseHE42D0, 1, 1, "B"); // average A
16604  gPad->SetGridy();
16605  gPad->SetGridx(); // gPad->SetLogz();
16606  GefzRreconoiseHE42DF->SetXTitle("<R>_depth #eta \b");
16607  GefzRreconoiseHE42DF->SetYTitle(" #phi \b");
16608  GefzRreconoiseHE42DF->Draw("COLZ");
16609 
16610  c2x1->cd(2);
16611  TH1F *energyhitNoise_HE = (TH1F *)dir->FindObjectAny("h_energyhitNoise_HE");
16612  energyhitNoise_HE->SetMarkerStyle(20);
16613  energyhitNoise_HE->SetMarkerSize(0.4);
16614  energyhitNoise_HE->GetYaxis()->SetLabelSize(0.04);
16615  energyhitNoise_HE->SetXTitle("energyhitNoise_HE \b");
16616  energyhitNoise_HE->SetMarkerColor(2);
16617  energyhitNoise_HE->SetLineColor(0);
16618  gPad->SetGridy();
16619  gPad->SetGridx();
16620  energyhitNoise_HE->Draw("Error");
16621 
16623  c2x1->Update();
16624  c2x1->Print("RreconoiseGeneralD2PhiSymmetryHE.png");
16625  c2x1->Clear();
16626  // clean-up
16627  if (GefzRreconoiseHE42D)
16628  delete GefzRreconoiseHE42D;
16629  if (GefzRreconoiseHE42D0)
16630  delete GefzRreconoiseHE42D0;
16631  if (GefzRreconoiseHE42DF)
16632  delete GefzRreconoiseHE42DF;
16633  //====================================================================== 1D plot: R vs phi , averaged over depthes & eta
16634  //======================================================================
16635  //cout<<" 1D plot: R vs phi , averaged over depthes & eta *****" <<endl;
16636  c1x1->Clear();
16638  c1x1->Divide(1, 1);
16639  c1x1->cd(1);
16640  TH1F *GefzRreconoiseHE41D = new TH1F("GefzRreconoiseHE41D", "", nphi, 0., 72.);
16641  TH1F *GefzRreconoiseHE41D0 = new TH1F("GefzRreconoiseHE41D0", "", nphi, 0., 72.);
16642  TH1F *GefzRreconoiseHE41DF = (TH1F *)GefzRreconoiseHE41D0->Clone("GefzRreconoiseHE41DF");
16643  for (int jphi = 0; jphi < nphi; jphi++) {
16644  for (int jeta = 0; jeta < neta; jeta++) {
16645  if ((jeta - 41 >= -29 && jeta - 41 <= -16) || (jeta - 41 >= 15 && jeta - 41 <= 28)) {
16646  for (int i = 0; i < ndepth; i++) {
16647  double ccc1 = areconoisehe[i][jeta][jphi];
16648  if (ccc1 != 0.) {
16649  GefzRreconoiseHE41D->Fill(jphi, ccc1);
16650  GefzRreconoiseHE41D0->Fill(jphi, 1.);
16651  }
16652  }
16653  }
16654  }
16655  }
16656  GefzRreconoiseHE41DF->Divide(GefzRreconoiseHE41D, GefzRreconoiseHE41D0, 1, 1, "B"); // R averaged over depthes & eta
16657  GefzRreconoiseHE41D0->Sumw2();
16658  // for (int jphi=1;jphi<73;jphi++) {GefzRreconoiseHE41DF->SetBinError(jphi,0.01);}
16659  gPad->SetGridy();
16660  gPad->SetGridx(); // gPad->SetLogz();
16661  GefzRreconoiseHE41DF->SetMarkerStyle(20);
16662  GefzRreconoiseHE41DF->SetMarkerSize(1.4);
16663  GefzRreconoiseHE41DF->GetZaxis()->SetLabelSize(0.08);
16664  GefzRreconoiseHE41DF->SetXTitle("#phi \b");
16665  GefzRreconoiseHE41DF->SetYTitle(" <R> \b");
16666  GefzRreconoiseHE41DF->SetZTitle("<R>_PHI - AllDepthes \b");
16667  GefzRreconoiseHE41DF->SetMarkerColor(4);
16668  GefzRreconoiseHE41DF->SetLineColor(
16669  4); // GefzRreconoiseHE41DF->SetMinimum(0.8); // GefzRreconoiseHE41DF->SetMaximum(1.000);
16670  GefzRreconoiseHE41DF->Draw("Error");
16672  c1x1->Update();
16673  c1x1->Print("RreconoiseGeneralD1PhiSymmetryHE.png");
16674  c1x1->Clear();
16675  // clean-up
16676  if (GefzRreconoiseHE41D)
16677  delete GefzRreconoiseHE41D;
16678  if (GefzRreconoiseHE41D0)
16679  delete GefzRreconoiseHE41D0;
16680  if (GefzRreconoiseHE41DF)
16681  delete GefzRreconoiseHE41DF;
16682 
16683  //========================================================================================== 4
16684  //======================================================================
16685  //======================================================================1D plot: R vs phi , different eta, depth=1
16686  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
16687  c3x5->Clear();
16689  c3x5->Divide(3, 5);
16690  c3x5->cd(1);
16691  int kcountHEpositivedirectionReconoise1 = 1;
16692  TH1F *h2CeffHEpositivedirectionReconoise1 = new TH1F("h2CeffHEpositivedirectionReconoise1", "", nphi, 0., 72.);
16693  for (int jeta = 0; jeta < njeta; jeta++) {
16694  // positivedirectionReconoise:
16695  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
16696  // for (int i=0;i<ndepth;i++) {
16697  // depth=1
16698  for (int i = 0; i < 1; i++) {
16699  TH1F *HEpositivedirectionReconoise1 = (TH1F *)h2CeffHEpositivedirectionReconoise1->Clone("twod1");
16700  float ccctest = 0; // to avoid empty massive elements
16701  for (int jphi = 0; jphi < nphi; jphi++) {
16702  double ccc1 = areconoisehe[i][jeta][jphi];
16703  if (ccc1 != 0.) {
16704  HEpositivedirectionReconoise1->Fill(jphi, ccc1);
16705  ccctest = 1.; //HEpositivedirectionReconoise1->SetBinError(i,0.01);
16706  }
16707  } // for jphi
16708  if (ccctest > 0.) {
16709  // cout<<"444 kcountHEpositivedirectionReconoise1 = "<<kcountHEpositivedirectionReconoise1 <<" jeta-41= "<< jeta-41 <<endl;
16710  c3x5->cd(kcountHEpositivedirectionReconoise1);
16711  HEpositivedirectionReconoise1->SetMarkerStyle(20);
16712  HEpositivedirectionReconoise1->SetMarkerSize(0.4);
16713  HEpositivedirectionReconoise1->GetYaxis()->SetLabelSize(0.04);
16714  HEpositivedirectionReconoise1->SetXTitle("HEpositivedirectionReconoise1 \b");
16715  HEpositivedirectionReconoise1->SetMarkerColor(2);
16716  HEpositivedirectionReconoise1->SetLineColor(0);
16717  gPad->SetGridy();
16718  gPad->SetGridx();
16719  // gPad->SetLogy();
16720  if (kcountHEpositivedirectionReconoise1 == 1)
16721  HEpositivedirectionReconoise1->SetXTitle("R for HE+ jeta = 17; depth = 1 \b");
16722  if (kcountHEpositivedirectionReconoise1 == 2)
16723  HEpositivedirectionReconoise1->SetXTitle("R for HE+ jeta = 18; depth = 1 \b");
16724  if (kcountHEpositivedirectionReconoise1 == 3)
16725  HEpositivedirectionReconoise1->SetXTitle("R for HE+ jeta = 19; depth = 1 \b");
16726  if (kcountHEpositivedirectionReconoise1 == 4)
16727  HEpositivedirectionReconoise1->SetXTitle("R for HE+ jeta = 20; depth = 1 \b");
16728  if (kcountHEpositivedirectionReconoise1 == 5)
16729  HEpositivedirectionReconoise1->SetXTitle("R for HE+ jeta = 21; depth = 1 \b");
16730  if (kcountHEpositivedirectionReconoise1 == 6)
16731  HEpositivedirectionReconoise1->SetXTitle("R for HE+ jeta = 22; depth = 1 \b");
16732  if (kcountHEpositivedirectionReconoise1 == 7)
16733  HEpositivedirectionReconoise1->SetXTitle("R for HE+ jeta = 23; depth = 1 \b");
16734  if (kcountHEpositivedirectionReconoise1 == 8)
16735  HEpositivedirectionReconoise1->SetXTitle("R for HE+ jeta = 24; depth = 1 \b");
16736  if (kcountHEpositivedirectionReconoise1 == 9)
16737  HEpositivedirectionReconoise1->SetXTitle("R for HE+ jeta = 25; depth = 1 \b");
16738  if (kcountHEpositivedirectionReconoise1 == 10)
16739  HEpositivedirectionReconoise1->SetXTitle("R for HE+ jeta = 26; depth = 1 \b");
16740  if (kcountHEpositivedirectionReconoise1 == 11)
16741  HEpositivedirectionReconoise1->SetXTitle("R for HE+ jeta = 27; depth = 1 \b");
16742  if (kcountHEpositivedirectionReconoise1 == 12)
16743  HEpositivedirectionReconoise1->SetXTitle("R for HE+ jeta = 28; depth = 1 \b");
16744  HEpositivedirectionReconoise1->Draw("Error");
16745  kcountHEpositivedirectionReconoise1++;
16746  if (kcountHEpositivedirectionReconoise1 > 12)
16747  break; // 4x6 = 24
16748  } //ccctest>0
16749 
16750  } // for i
16751  } //if(jeta-41 >= 15 && jeta-41 <= 28
16752  } //for jeta
16754  c3x5->Update();
16755  c3x5->Print("RreconoisePositiveDirectionhistD1PhiSymmetryDepth1HE.png");
16756  c3x5->Clear();
16757  // clean-up
16758  if (h2CeffHEpositivedirectionReconoise1)
16759  delete h2CeffHEpositivedirectionReconoise1;
16760 
16761  //========================================================================================== 5
16762  //======================================================================
16763  //======================================================================1D plot: R vs phi , different eta, depth=2
16764  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
16765  c3x5->Clear();
16767  c3x5->Divide(3, 5);
16768  c3x5->cd(1);
16769  int kcountHEpositivedirectionReconoise2 = 1;
16770  TH1F *h2CeffHEpositivedirectionReconoise2 = new TH1F("h2CeffHEpositivedirectionReconoise2", "", nphi, 0., 72.);
16771  for (int jeta = 0; jeta < njeta; jeta++) {
16772  // positivedirectionReconoise:
16773  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
16774  // for (int i=0;i<ndepth;i++) {
16775  // depth=2
16776  for (int i = 1; i < 2; i++) {
16777  TH1F *HEpositivedirectionReconoise2 = (TH1F *)h2CeffHEpositivedirectionReconoise2->Clone("twod1");
16778  float ccctest = 0; // to avoid empty massive elements
16779  for (int jphi = 0; jphi < nphi; jphi++) {
16780  double ccc1 = areconoisehe[i][jeta][jphi];
16781  if (ccc1 != 0.) {
16782  HEpositivedirectionReconoise2->Fill(jphi, ccc1);
16783  ccctest = 1.; //HEpositivedirectionReconoise2->SetBinError(i,0.01);
16784  }
16785  } // for jphi
16786  if (ccctest > 0.) {
16787  //cout<<"555 kcountHEpositivedirectionReconoise2 = "<<kcountHEpositivedirectionReconoise2 <<" jeta-41= "<< jeta-41 <<endl;
16788  c3x5->cd(kcountHEpositivedirectionReconoise2);
16789  HEpositivedirectionReconoise2->SetMarkerStyle(20);
16790  HEpositivedirectionReconoise2->SetMarkerSize(0.4);
16791  HEpositivedirectionReconoise2->GetYaxis()->SetLabelSize(0.04);
16792  HEpositivedirectionReconoise2->SetXTitle("HEpositivedirectionReconoise2 \b");
16793  HEpositivedirectionReconoise2->SetMarkerColor(2);
16794  HEpositivedirectionReconoise2->SetLineColor(0);
16795  gPad->SetGridy();
16796  gPad->SetGridx();
16797  // gPad->SetLogy();
16798  if (kcountHEpositivedirectionReconoise2 == 1)
16799  HEpositivedirectionReconoise2->SetXTitle("R for HE+ jeta = 16; depth = 2 \b");
16800  if (kcountHEpositivedirectionReconoise2 == 2)
16801  HEpositivedirectionReconoise2->SetXTitle("R for HE+ jeta = 17; depth = 2 \b");
16802  if (kcountHEpositivedirectionReconoise2 == 3)
16803  HEpositivedirectionReconoise2->SetXTitle("R for HE+ jeta = 18; depth = 2 \b");
16804  if (kcountHEpositivedirectionReconoise2 == 4)
16805  HEpositivedirectionReconoise2->SetXTitle("R for HE+ jeta = 19; depth = 2 \b");
16806  if (kcountHEpositivedirectionReconoise2 == 5)
16807  HEpositivedirectionReconoise2->SetXTitle("R for HE+ jeta = 20; depth = 2 \b");
16808  if (kcountHEpositivedirectionReconoise2 == 6)
16809  HEpositivedirectionReconoise2->SetXTitle("R for HE+ jeta = 21; depth = 2 \b");
16810  if (kcountHEpositivedirectionReconoise2 == 7)
16811  HEpositivedirectionReconoise2->SetXTitle("R for HE+ jeta = 22; depth = 2 \b");
16812  if (kcountHEpositivedirectionReconoise2 == 8)
16813  HEpositivedirectionReconoise2->SetXTitle("R for HE+ jeta = 23; depth = 2 \b");
16814  if (kcountHEpositivedirectionReconoise2 == 9)
16815  HEpositivedirectionReconoise2->SetXTitle("R for HE+ jeta = 24; depth = 2 \b");
16816  if (kcountHEpositivedirectionReconoise2 == 10)
16817  HEpositivedirectionReconoise2->SetXTitle("R for HE+ jeta = 25; depth = 2 \b");
16818  if (kcountHEpositivedirectionReconoise2 == 11)
16819  HEpositivedirectionReconoise2->SetXTitle("R for HE+ jeta = 26; depth = 2 \b");
16820  if (kcountHEpositivedirectionReconoise2 == 12)
16821  HEpositivedirectionReconoise2->SetXTitle("R for HE+ jeta = 27; depth = 2 \b");
16822  if (kcountHEpositivedirectionReconoise2 == 13)
16823  HEpositivedirectionReconoise2->SetXTitle("R for HE+ jeta = 28; depth = 2 \b");
16824  HEpositivedirectionReconoise2->Draw("Error");
16825  kcountHEpositivedirectionReconoise2++;
16826  if (kcountHEpositivedirectionReconoise2 > 13)
16827  break; // 4x6 = 24
16828  } //ccctest>0
16829 
16830  } // for i
16831  } //if(jeta-41
16832  } //for jeta
16834  c3x5->Update();
16835  c3x5->Print("RreconoisePositiveDirectionhistD1PhiSymmetryDepth2HE.png");
16836  c3x5->Clear();
16837  // clean-up
16838  if (h2CeffHEpositivedirectionReconoise2)
16839  delete h2CeffHEpositivedirectionReconoise2;
16840  //========================================================================================== 6
16841  //======================================================================
16842  //======================================================================1D plot: R vs phi , different eta, depth=3
16843  //cout<<" 1D plot: R vs phi , different eta, depth=3 *****" <<endl;
16844  c3x5->Clear();
16846  c3x5->Divide(3, 5);
16847  c3x5->cd(1);
16848  int kcountHEpositivedirectionReconoise3 = 1;
16849  TH1F *h2CeffHEpositivedirectionReconoise3 = new TH1F("h2CeffHEpositivedirectionReconoise3", "", nphi, 0., 72.);
16850  for (int jeta = 0; jeta < njeta; jeta++) {
16851  // positivedirectionReconoise:
16852  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
16853  // for (int i=0;i<ndepth;i++) {
16854  // depth=3
16855  for (int i = 2; i < 3; i++) {
16856  TH1F *HEpositivedirectionReconoise3 = (TH1F *)h2CeffHEpositivedirectionReconoise3->Clone("twod1");
16857  float ccctest = 0; // to avoid empty massive elements
16858  for (int jphi = 0; jphi < nphi; jphi++) {
16859  double ccc1 = areconoisehe[i][jeta][jphi];
16860  if (ccc1 != 0.) {
16861  HEpositivedirectionReconoise3->Fill(jphi, ccc1);
16862  ccctest = 1.; //HEpositivedirectionReconoise3->SetBinError(i,0.01);
16863  }
16864  } // for jphi
16865  if (ccctest > 0.) {
16866  //cout<<"666 kcountHEpositivedirectionReconoise3 = "<<kcountHEpositivedirectionReconoise3 <<" jeta-41= "<< jeta-41 <<endl;
16867  c3x5->cd(kcountHEpositivedirectionReconoise3);
16868  HEpositivedirectionReconoise3->SetMarkerStyle(20);
16869  HEpositivedirectionReconoise3->SetMarkerSize(0.4);
16870  HEpositivedirectionReconoise3->GetYaxis()->SetLabelSize(0.04);
16871  HEpositivedirectionReconoise3->SetXTitle("HEpositivedirectionReconoise3 \b");
16872  HEpositivedirectionReconoise3->SetMarkerColor(2);
16873  HEpositivedirectionReconoise3->SetLineColor(0);
16874  gPad->SetGridy();
16875  gPad->SetGridx();
16876  // gPad->SetLogy();
16877  if (kcountHEpositivedirectionReconoise3 == 1)
16878  HEpositivedirectionReconoise3->SetXTitle("R for HE+ jeta = 16; depth = 3 \b");
16879  if (kcountHEpositivedirectionReconoise3 == 2)
16880  HEpositivedirectionReconoise3->SetXTitle("R for HE+ jeta = 17; depth = 3 \b");
16881  if (kcountHEpositivedirectionReconoise3 == 3)
16882  HEpositivedirectionReconoise3->SetXTitle("R for HE+ jeta = 18; depth = 3 \b");
16883  if (kcountHEpositivedirectionReconoise3 == 4)
16884  HEpositivedirectionReconoise3->SetXTitle("R for HE+ jeta = 19; depth = 3 \b");
16885  if (kcountHEpositivedirectionReconoise3 == 5)
16886  HEpositivedirectionReconoise3->SetXTitle("R for HE+ jeta = 20; depth = 3 \b");
16887  if (kcountHEpositivedirectionReconoise3 == 6)
16888  HEpositivedirectionReconoise3->SetXTitle("R for HE+ jeta = 21; depth = 3 \b");
16889  if (kcountHEpositivedirectionReconoise3 == 7)
16890  HEpositivedirectionReconoise3->SetXTitle("R for HE+ jeta = 22; depth = 3 \b");
16891  if (kcountHEpositivedirectionReconoise3 == 8)
16892  HEpositivedirectionReconoise3->SetXTitle("R for HE+ jeta = 23; depth = 3 \b");
16893  if (kcountHEpositivedirectionReconoise3 == 9)
16894  HEpositivedirectionReconoise3->SetXTitle("R for HE+ jeta = 24; depth = 3 \b");
16895  if (kcountHEpositivedirectionReconoise3 == 10)
16896  HEpositivedirectionReconoise3->SetXTitle("R for HE+ jeta = 25; depth = 3 \b");
16897  if (kcountHEpositivedirectionReconoise3 == 11)
16898  HEpositivedirectionReconoise3->SetXTitle("R for HE+ jeta = 26; depth = 3 \b");
16899  if (kcountHEpositivedirectionReconoise3 == 12)
16900  HEpositivedirectionReconoise3->SetXTitle("R for HE+ jeta = 27; depth = 3 \b");
16901  if (kcountHEpositivedirectionReconoise3 == 13)
16902  HEpositivedirectionReconoise3->SetXTitle("R for HE+ jeta = 28; depth = 3 \b");
16903  HEpositivedirectionReconoise3->Draw("Error");
16904  kcountHEpositivedirectionReconoise3++;
16905  if (kcountHEpositivedirectionReconoise3 > 13)
16906  break; // 4x6 = 24
16907  } //ccctest>0
16908 
16909  } // for i
16910  } //if(jeta-41 >=
16911  } //for jeta
16913  c3x5->Update();
16914  c3x5->Print("RreconoisePositiveDirectionhistD1PhiSymmetryDepth3HE.png");
16915  c3x5->Clear();
16916  // clean-up
16917  if (h2CeffHEpositivedirectionReconoise3)
16918  delete h2CeffHEpositivedirectionReconoise3;
16919  //========================================================================================== 7
16920  //======================================================================
16921  //======================================================================1D plot: R vs phi , different eta, depth=4
16922  //cout<<" 1D plot: R vs phi , different eta, depth=4 *****" <<endl;
16923  c3x5->Clear();
16925  c3x5->Divide(3, 5);
16926  c3x5->cd(1);
16927  int kcountHEpositivedirectionReconoise4 = 1;
16928  TH1F *h2CeffHEpositivedirectionReconoise4 = new TH1F("h2CeffHEpositivedirectionReconoise4", "", nphi, 0., 72.);
16929 
16930  for (int jeta = 0; jeta < njeta; jeta++) {
16931  // positivedirectionReconoise:
16932  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
16933  // for (int i=0;i<ndepth;i++) {
16934  // depth=4
16935  for (int i = 3; i < 4; i++) {
16936  TH1F *HEpositivedirectionReconoise4 = (TH1F *)h2CeffHEpositivedirectionReconoise4->Clone("twod1");
16937 
16938  float ccctest = 0; // to avoid empty massive elements
16939  for (int jphi = 0; jphi < nphi; jphi++) {
16940  double ccc1 = areconoisehe[i][jeta][jphi];
16941  if (ccc1 != 0.) {
16942  HEpositivedirectionReconoise4->Fill(jphi, ccc1);
16943  ccctest = 1.; //HEpositivedirectionReconoise4->SetBinError(i,0.01);
16944  }
16945  } // for jphi
16946  if (ccctest > 0.) {
16947  //cout<<"777 kcountHEpositivedirectionReconoise4 = "<<kcountHEpositivedirectionReconoise4 <<" jeta-41= "<< jeta-41 <<endl;
16948  c3x5->cd(kcountHEpositivedirectionReconoise4);
16949  HEpositivedirectionReconoise4->SetMarkerStyle(20);
16950  HEpositivedirectionReconoise4->SetMarkerSize(0.4);
16951  HEpositivedirectionReconoise4->GetYaxis()->SetLabelSize(0.04);
16952  HEpositivedirectionReconoise4->SetXTitle("HEpositivedirectionReconoise4 \b");
16953  HEpositivedirectionReconoise4->SetMarkerColor(2);
16954  HEpositivedirectionReconoise4->SetLineColor(0);
16955  gPad->SetGridy();
16956  gPad->SetGridx();
16957  // gPad->SetLogy();
16958  if (kcountHEpositivedirectionReconoise4 == 1)
16959  HEpositivedirectionReconoise4->SetXTitle("R for HE+ jeta = 15; depth = 4 \b");
16960  if (kcountHEpositivedirectionReconoise4 == 2)
16961  HEpositivedirectionReconoise4->SetXTitle("R for HE+ jeta = 17; depth = 4 \b");
16962  if (kcountHEpositivedirectionReconoise4 == 3)
16963  HEpositivedirectionReconoise4->SetXTitle("R for HE+ jeta = 18; depth = 4 \b");
16964  if (kcountHEpositivedirectionReconoise4 == 4)
16965  HEpositivedirectionReconoise4->SetXTitle("R for HE+ jeta = 19; depth = 4 \b");
16966  if (kcountHEpositivedirectionReconoise4 == 5)
16967  HEpositivedirectionReconoise4->SetXTitle("R for HE+ jeta = 20; depth = 4 \b");
16968  if (kcountHEpositivedirectionReconoise4 == 6)
16969  HEpositivedirectionReconoise4->SetXTitle("R for HE+ jeta = 21; depth = 4 \b");
16970  if (kcountHEpositivedirectionReconoise4 == 7)
16971  HEpositivedirectionReconoise4->SetXTitle("R for HE+ jeta = 22; depth = 4 \b");
16972  if (kcountHEpositivedirectionReconoise4 == 8)
16973  HEpositivedirectionReconoise4->SetXTitle("R for HE+ jeta = 23; depth = 4 \b");
16974  if (kcountHEpositivedirectionReconoise4 == 9)
16975  HEpositivedirectionReconoise4->SetXTitle("R for HE+ jeta = 24; depth = 4 \b");
16976  if (kcountHEpositivedirectionReconoise4 == 10)
16977  HEpositivedirectionReconoise4->SetXTitle("R for HE+ jeta = 25; depth = 4 \b");
16978  if (kcountHEpositivedirectionReconoise4 == 11)
16979  HEpositivedirectionReconoise4->SetXTitle("R for HE+ jeta = 26; depth = 4 \b");
16980  if (kcountHEpositivedirectionReconoise4 == 12)
16981  HEpositivedirectionReconoise4->SetXTitle("R for HE+ jeta = 27; depth = 4 \b");
16982  HEpositivedirectionReconoise4->Draw("Error");
16983  kcountHEpositivedirectionReconoise4++;
16984  if (kcountHEpositivedirectionReconoise4 > 12)
16985  break; // 4x6 = 24
16986  } //ccctest>0
16987 
16988  } // for i
16989  } //if(jeta-41 >= -29 && jeta-41 <= -16)
16990  } //for jeta
16992  c3x5->Update();
16993  c3x5->Print("RreconoisePositiveDirectionhistD1PhiSymmetryDepth4HE.png");
16994  c3x5->Clear();
16995  // clean-up
16996  if (h2CeffHEpositivedirectionReconoise4)
16997  delete h2CeffHEpositivedirectionReconoise4;
16998  //========================================================================================== 8
16999  //======================================================================
17000  //======================================================================1D plot: R vs phi , different eta, depth=5
17001  //cout<<" 1D plot: R vs phi , different eta, depth=5 *****" <<endl;
17002  c3x5->Clear();
17004  c3x5->Divide(3, 5);
17005  c3x5->cd(1);
17006  int kcountHEpositivedirectionReconoise5 = 1;
17007  TH1F *h2CeffHEpositivedirectionReconoise5 = new TH1F("h2CeffHEpositivedirectionReconoise5", "", nphi, 0., 72.);
17008 
17009  for (int jeta = 0; jeta < njeta; jeta++) {
17010  // positivedirectionReconoise:
17011  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
17012  // for (int i=0;i<ndepth;i++) {
17013  // depth=5
17014  for (int i = 4; i < 5; i++) {
17015  TH1F *HEpositivedirectionReconoise5 = (TH1F *)h2CeffHEpositivedirectionReconoise5->Clone("twod1");
17016 
17017  float ccctest = 0; // to avoid empty massive elements
17018  for (int jphi = 0; jphi < nphi; jphi++) {
17019  // cout<<"888 initial kcountHEpositivedirectionReconoise5 = "<<kcountHEpositivedirectionReconoise5 <<" jeta-41= "<< jeta-41 <<" jphi= "<< jphi <<" areconoisehe[i][jeta][jphi]= "<< areconoisehe[i][jeta][jphi] <<" depth= "<< i <<endl;
17020 
17021  double ccc1 = areconoisehe[i][jeta][jphi];
17022  if (ccc1 != 0.) {
17023  HEpositivedirectionReconoise5->Fill(jphi, ccc1);
17024  ccctest = 1.; //HEpositivedirectionReconoise5->SetBinError(i,0.01);
17025  }
17026  } // for jphi
17027  if (ccctest > 0.) {
17028  //cout<<"888 kcountHEpositivedirectionReconoise5 = "<<kcountHEpositivedirectionReconoise5 <<" jeta-41= "<< jeta-41 <<endl;
17029  c3x5->cd(kcountHEpositivedirectionReconoise5);
17030  HEpositivedirectionReconoise5->SetMarkerStyle(20);
17031  HEpositivedirectionReconoise5->SetMarkerSize(0.4);
17032  HEpositivedirectionReconoise5->GetYaxis()->SetLabelSize(0.04);
17033  HEpositivedirectionReconoise5->SetXTitle("HEpositivedirectionReconoise5 \b");
17034  HEpositivedirectionReconoise5->SetMarkerColor(2);
17035  HEpositivedirectionReconoise5->SetLineColor(0);
17036  gPad->SetGridy();
17037  gPad->SetGridx();
17038  // gPad->SetLogy();
17039  if (kcountHEpositivedirectionReconoise5 == 1)
17040  HEpositivedirectionReconoise5->SetXTitle("R for HE+ jeta = 17; depth = 5 \b");
17041  if (kcountHEpositivedirectionReconoise5 == 2)
17042  HEpositivedirectionReconoise5->SetXTitle("R for HE+ jeta = 18; depth = 5 \b");
17043  if (kcountHEpositivedirectionReconoise5 == 3)
17044  HEpositivedirectionReconoise5->SetXTitle("R for HE+ jeta = 19; depth = 5 \b");
17045  if (kcountHEpositivedirectionReconoise5 == 4)
17046  HEpositivedirectionReconoise5->SetXTitle("R for HE+ jeta = 20; depth = 5 \b");
17047  if (kcountHEpositivedirectionReconoise5 == 5)
17048  HEpositivedirectionReconoise5->SetXTitle("R for HE+ jeta = 21; depth = 5 \b");
17049  if (kcountHEpositivedirectionReconoise5 == 6)
17050  HEpositivedirectionReconoise5->SetXTitle("R for HE+ jeta = 22; depth = 5 \b");
17051  if (kcountHEpositivedirectionReconoise5 == 7)
17052  HEpositivedirectionReconoise5->SetXTitle("R for HE+ jeta = 23; depth = 5 \b");
17053  if (kcountHEpositivedirectionReconoise5 == 8)
17054  HEpositivedirectionReconoise5->SetXTitle("R for HE+ jeta = 24; depth = 5 \b");
17055  if (kcountHEpositivedirectionReconoise5 == 9)
17056  HEpositivedirectionReconoise5->SetXTitle("R for HE+ jeta = 25; depth = 5 \b");
17057  if (kcountHEpositivedirectionReconoise5 == 10)
17058  HEpositivedirectionReconoise5->SetXTitle("R for HE+ jeta = 26; depth = 5 \b");
17059  if (kcountHEpositivedirectionReconoise5 == 11)
17060  HEpositivedirectionReconoise5->SetXTitle("R for HE+ jeta = 27; depth = 5 \b");
17061  HEpositivedirectionReconoise5->Draw("Error");
17062  kcountHEpositivedirectionReconoise5++;
17063  if (kcountHEpositivedirectionReconoise5 > 11)
17064  break; // 4x6 = 24
17065  } //ccctest>0
17066 
17067  } // for i
17068  } //if(jeta-41 >= -29 && jeta-41 <= -16)
17069  } //for jeta
17071  c3x5->Update();
17072  c3x5->Print("RreconoisePositiveDirectionhistD1PhiSymmetryDepth5HE.png");
17073  c3x5->Clear();
17074  // clean-up
17075  if (h2CeffHEpositivedirectionReconoise5)
17076  delete h2CeffHEpositivedirectionReconoise5;
17077  //========================================================================================== 9
17078  //======================================================================
17079  //======================================================================1D plot: R vs phi , different eta, depth=6
17080  //cout<<" 1D plot: R vs phi , different eta, depth=6 *****" <<endl;
17081  c3x5->Clear();
17083  c3x5->Divide(3, 5);
17084  c3x5->cd(1);
17085  int kcountHEpositivedirectionReconoise6 = 1;
17086  TH1F *h2CeffHEpositivedirectionReconoise6 = new TH1F("h2CeffHEpositivedirectionReconoise6", "", nphi, 0., 72.);
17087 
17088  for (int jeta = 0; jeta < njeta; jeta++) {
17089  // positivedirectionReconoise:
17090  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
17091  // for (int i=0;i<ndepth;i++) {
17092  // depth=6
17093  for (int i = 5; i < 6; i++) {
17094  TH1F *HEpositivedirectionReconoise6 = (TH1F *)h2CeffHEpositivedirectionReconoise6->Clone("twod1");
17095 
17096  float ccctest = 0; // to avoid empty massive elements
17097  for (int jphi = 0; jphi < nphi; jphi++) {
17098  double ccc1 = areconoisehe[i][jeta][jphi];
17099  if (ccc1 != 0.) {
17100  HEpositivedirectionReconoise6->Fill(jphi, ccc1);
17101  ccctest = 1.; //HEpositivedirectionReconoise6->SetBinError(i,0.01);
17102  }
17103  } // for jphi
17104  if (ccctest > 0.) {
17105  //cout<<"999 kcountHEpositivedirectionReconoise6 = "<<kcountHEpositivedirectionReconoise6 <<" jeta-41= "<< jeta-41 <<endl;
17106  c3x5->cd(kcountHEpositivedirectionReconoise6);
17107  HEpositivedirectionReconoise6->SetMarkerStyle(20);
17108  HEpositivedirectionReconoise6->SetMarkerSize(0.4);
17109  HEpositivedirectionReconoise6->GetYaxis()->SetLabelSize(0.04);
17110  HEpositivedirectionReconoise6->SetXTitle("HEpositivedirectionReconoise6 \b");
17111  HEpositivedirectionReconoise6->SetMarkerColor(2);
17112  HEpositivedirectionReconoise6->SetLineColor(0);
17113  gPad->SetGridy();
17114  gPad->SetGridx();
17115  // gPad->SetLogy();
17116  if (kcountHEpositivedirectionReconoise6 == 1)
17117  HEpositivedirectionReconoise6->SetXTitle("R for HE+ jeta = 18; depth = 6 \b");
17118  if (kcountHEpositivedirectionReconoise6 == 2)
17119  HEpositivedirectionReconoise6->SetXTitle("R for HE+ jeta = 19; depth = 6 \b");
17120  if (kcountHEpositivedirectionReconoise6 == 3)
17121  HEpositivedirectionReconoise6->SetXTitle("R for HE+ jeta = 20; depth = 6 \b");
17122  if (kcountHEpositivedirectionReconoise6 == 4)
17123  HEpositivedirectionReconoise6->SetXTitle("R for HE+ jeta = 21; depth = 6 \b");
17124  if (kcountHEpositivedirectionReconoise6 == 5)
17125  HEpositivedirectionReconoise6->SetXTitle("R for HE+ jeta = 22; depth = 6 \b");
17126  if (kcountHEpositivedirectionReconoise6 == 6)
17127  HEpositivedirectionReconoise6->SetXTitle("R for HE+ jeta = 23; depth = 6 \b");
17128  if (kcountHEpositivedirectionReconoise6 == 7)
17129  HEpositivedirectionReconoise6->SetXTitle("R for HE+ jeta = 24; depth = 6 \b");
17130  if (kcountHEpositivedirectionReconoise6 == 8)
17131  HEpositivedirectionReconoise6->SetXTitle("R for HE+ jeta = 25; depth = 6 \b");
17132  if (kcountHEpositivedirectionReconoise6 == 9)
17133  HEpositivedirectionReconoise6->SetXTitle("R for HE+ jeta = 26; depth = 6 \b");
17134  if (kcountHEpositivedirectionReconoise6 == 10)
17135  HEpositivedirectionReconoise6->SetXTitle("R for HE+ jeta = 27; depth = 6 \b");
17136  HEpositivedirectionReconoise6->Draw("Error");
17137  kcountHEpositivedirectionReconoise6++;
17138  if (kcountHEpositivedirectionReconoise6 > 10)
17139  break; // 4x6 = 24
17140  } //ccctest>0
17141 
17142  } // for i
17143  } //if(jeta-41 >= -29 && jeta-41 <= -16)
17144  } //for jeta
17146  c3x5->Update();
17147  c3x5->Print("RreconoisePositiveDirectionhistD1PhiSymmetryDepth6HE.png");
17148  c3x5->Clear();
17149  // clean-up
17150  if (h2CeffHEpositivedirectionReconoise6)
17151  delete h2CeffHEpositivedirectionReconoise6;
17152  //========================================================================================== 10
17153  //======================================================================
17154  //======================================================================1D plot: R vs phi , different eta, depth=7
17155  //cout<<" 1D plot: R vs phi , different eta, depth=7 *****" <<endl;
17156  c3x5->Clear();
17158  c3x5->Divide(3, 5);
17159  c3x5->cd(1);
17160  int kcountHEpositivedirectionReconoise7 = 1;
17161  TH1F *h2CeffHEpositivedirectionReconoise7 = new TH1F("h2CeffHEpositivedirectionReconoise7", "", nphi, 0., 72.);
17162 
17163  for (int jeta = 0; jeta < njeta; jeta++) {
17164  // positivedirectionReconoise:
17165  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
17166  // for (int i=0;i<ndepth;i++) {
17167  // depth=7
17168  for (int i = 6; i < 7; i++) {
17169  TH1F *HEpositivedirectionReconoise7 = (TH1F *)h2CeffHEpositivedirectionReconoise7->Clone("twod1");
17170 
17171  float ccctest = 0; // to avoid empty massive elements
17172  for (int jphi = 0; jphi < nphi; jphi++) {
17173  double ccc1 = areconoisehe[i][jeta][jphi];
17174  if (ccc1 != 0.) {
17175  HEpositivedirectionReconoise7->Fill(jphi, ccc1);
17176  ccctest = 1.; //HEpositivedirectionReconoise7->SetBinError(i,0.01);
17177  }
17178  } // for jphi
17179  if (ccctest > 0.) {
17180  //cout<<"1010 kcountHEpositivedirectionReconoise7 = "<<kcountHEpositivedirectionReconoise7 <<" jeta-41= "<< jeta-41 <<endl;
17181  c3x5->cd(kcountHEpositivedirectionReconoise7);
17182  HEpositivedirectionReconoise7->SetMarkerStyle(20);
17183  HEpositivedirectionReconoise7->SetMarkerSize(0.4);
17184  HEpositivedirectionReconoise7->GetYaxis()->SetLabelSize(0.04);
17185  HEpositivedirectionReconoise7->SetXTitle("HEpositivedirectionReconoise7 \b");
17186  HEpositivedirectionReconoise7->SetMarkerColor(2);
17187  HEpositivedirectionReconoise7->SetLineColor(0);
17188  gPad->SetGridy();
17189  gPad->SetGridx();
17190  // gPad->SetLogy();
17191  if (kcountHEpositivedirectionReconoise7 == 1)
17192  HEpositivedirectionReconoise7->SetXTitle("R for HE+ jeta = 25; depth = 7 \b");
17193  if (kcountHEpositivedirectionReconoise7 == 2)
17194  HEpositivedirectionReconoise7->SetXTitle("R for HE+ jeta = 26; depth = 7 \b");
17195  if (kcountHEpositivedirectionReconoise7 == 3)
17196  HEpositivedirectionReconoise7->SetXTitle("R for HE+ jeta = 27; depth = 7 \b");
17197  HEpositivedirectionReconoise7->Draw("Error");
17198  kcountHEpositivedirectionReconoise7++;
17199  if (kcountHEpositivedirectionReconoise7 > 3)
17200  break; //
17201  } //ccctest>0
17202 
17203  } // for i
17204  } //if(jeta-41 >= -29 && jeta-41 <= -16)
17205  } //for jeta
17207  c3x5->Update();
17208  c3x5->Print("RreconoisePositiveDirectionhistD1PhiSymmetryDepth7HE.png");
17209  c3x5->Clear();
17210  // clean-up
17211  if (h2CeffHEpositivedirectionReconoise7)
17212  delete h2CeffHEpositivedirectionReconoise7;
17213 
17215  //========================================================================================== 1114
17216  //======================================================================
17217  //======================================================================1D plot: R vs phi , different eta, depth=1
17218  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
17219  c3x5->Clear();
17221  c3x5->Divide(3, 5);
17222  c3x5->cd(1);
17223  int kcountHEnegativedirectionReconoise1 = 1;
17224  TH1F *h2CeffHEnegativedirectionReconoise1 = new TH1F("h2CeffHEnegativedirectionReconoise1", "", nphi, 0., 72.);
17225  for (int jeta = 0; jeta < njeta; jeta++) {
17226  // negativedirectionReconoise:
17227  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
17228  // for (int i=0;i<ndepth;i++) {
17229  // depth=1
17230  for (int i = 0; i < 1; i++) {
17231  TH1F *HEnegativedirectionReconoise1 = (TH1F *)h2CeffHEnegativedirectionReconoise1->Clone("twod1");
17232  float ccctest = 0; // to avoid empty massive elements
17233  for (int jphi = 0; jphi < nphi; jphi++) {
17234  double ccc1 = areconoisehe[i][jeta][jphi];
17235  if (ccc1 != 0.) {
17236  HEnegativedirectionReconoise1->Fill(jphi, ccc1);
17237  ccctest = 1.; //HEnegativedirectionReconoise1->SetBinError(i,0.01);
17238  }
17239  } // for jphi
17240  if (ccctest > 0.) {
17241  // cout<<"444 kcountHEnegativedirectionReconoise1 = "<<kcountHEnegativedirectionReconoise1 <<" jeta-41= "<< jeta-41 <<endl;
17242  c3x5->cd(kcountHEnegativedirectionReconoise1);
17243  HEnegativedirectionReconoise1->SetMarkerStyle(20);
17244  HEnegativedirectionReconoise1->SetMarkerSize(0.4);
17245  HEnegativedirectionReconoise1->GetYaxis()->SetLabelSize(0.04);
17246  HEnegativedirectionReconoise1->SetXTitle("HEnegativedirectionReconoise1 \b");
17247  HEnegativedirectionReconoise1->SetMarkerColor(2);
17248  HEnegativedirectionReconoise1->SetLineColor(0);
17249  gPad->SetGridy();
17250  gPad->SetGridx();
17251  // gPad->SetLogy();
17252  if (kcountHEnegativedirectionReconoise1 == 1)
17253  HEnegativedirectionReconoise1->SetXTitle("R for HE- jeta =-29; depth = 1 \b");
17254  if (kcountHEnegativedirectionReconoise1 == 2)
17255  HEnegativedirectionReconoise1->SetXTitle("R for HE- jeta =-28; depth = 1 \b");
17256  if (kcountHEnegativedirectionReconoise1 == 3)
17257  HEnegativedirectionReconoise1->SetXTitle("R for HE- jeta =-27; depth = 1 \b");
17258  if (kcountHEnegativedirectionReconoise1 == 4)
17259  HEnegativedirectionReconoise1->SetXTitle("R for HE- jeta =-26; depth = 1 \b");
17260  if (kcountHEnegativedirectionReconoise1 == 5)
17261  HEnegativedirectionReconoise1->SetXTitle("R for HE- jeta =-25; depth = 1 \b");
17262  if (kcountHEnegativedirectionReconoise1 == 6)
17263  HEnegativedirectionReconoise1->SetXTitle("R for HE- jeta =-24; depth = 1 \b");
17264  if (kcountHEnegativedirectionReconoise1 == 7)
17265  HEnegativedirectionReconoise1->SetXTitle("R for HE- jeta =-23; depth = 1 \b");
17266  if (kcountHEnegativedirectionReconoise1 == 8)
17267  HEnegativedirectionReconoise1->SetXTitle("R for HE- jeta =-22; depth = 1 \b");
17268  if (kcountHEnegativedirectionReconoise1 == 9)
17269  HEnegativedirectionReconoise1->SetXTitle("R for HE- jeta =-21; depth = 1 \b");
17270  if (kcountHEnegativedirectionReconoise1 == 10)
17271  HEnegativedirectionReconoise1->SetXTitle("R for HE- jeta =-20; depth = 1 \b");
17272  if (kcountHEnegativedirectionReconoise1 == 11)
17273  HEnegativedirectionReconoise1->SetXTitle("R for HE- jeta =-19; depth = 1 \b");
17274  if (kcountHEnegativedirectionReconoise1 == 12)
17275  HEnegativedirectionReconoise1->SetXTitle("R for HE- jeta =-18; depth = 1 \b");
17276  HEnegativedirectionReconoise1->Draw("Error");
17277  kcountHEnegativedirectionReconoise1++;
17278  if (kcountHEnegativedirectionReconoise1 > 12)
17279  break; // 4x6 = 24
17280  } //ccctest>0
17281 
17282  } // for i
17283  } //if(jeta-41 >= -29 && jeta-41 <= -16)
17284  } //for jeta
17286  c3x5->Update();
17287  c3x5->Print("RreconoiseNegativeDirectionhistD1PhiSymmetryDepth1HE.png");
17288  c3x5->Clear();
17289  // clean-up
17290  if (h2CeffHEnegativedirectionReconoise1)
17291  delete h2CeffHEnegativedirectionReconoise1;
17292 
17293  //========================================================================================== 1115
17294  //======================================================================
17295  //======================================================================1D plot: R vs phi , different eta, depth=2
17296  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
17297  c3x5->Clear();
17299  c3x5->Divide(3, 5);
17300  c3x5->cd(1);
17301  int kcountHEnegativedirectionReconoise2 = 1;
17302  TH1F *h2CeffHEnegativedirectionReconoise2 = new TH1F("h2CeffHEnegativedirectionReconoise2", "", nphi, 0., 72.);
17303  for (int jeta = 0; jeta < njeta; jeta++) {
17304  // negativedirectionReconoise:
17305  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
17306  // for (int i=0;i<ndepth;i++) {
17307  // depth=2
17308  for (int i = 1; i < 2; i++) {
17309  TH1F *HEnegativedirectionReconoise2 = (TH1F *)h2CeffHEnegativedirectionReconoise2->Clone("twod1");
17310  float ccctest = 0; // to avoid empty massive elements
17311  for (int jphi = 0; jphi < nphi; jphi++) {
17312  double ccc1 = areconoisehe[i][jeta][jphi];
17313  if (ccc1 != 0.) {
17314  HEnegativedirectionReconoise2->Fill(jphi, ccc1);
17315  ccctest = 1.; //HEnegativedirectionReconoise2->SetBinError(i,0.01);
17316  }
17317  } // for jphi
17318  if (ccctest > 0.) {
17319  //cout<<"555 kcountHEnegativedirectionReconoise2 = "<<kcountHEnegativedirectionReconoise2 <<" jeta-41= "<< jeta-41 <<endl;
17320  c3x5->cd(kcountHEnegativedirectionReconoise2);
17321  HEnegativedirectionReconoise2->SetMarkerStyle(20);
17322  HEnegativedirectionReconoise2->SetMarkerSize(0.4);
17323  HEnegativedirectionReconoise2->GetYaxis()->SetLabelSize(0.04);
17324  HEnegativedirectionReconoise2->SetXTitle("HEnegativedirectionReconoise2 \b");
17325  HEnegativedirectionReconoise2->SetMarkerColor(2);
17326  HEnegativedirectionReconoise2->SetLineColor(0);
17327  gPad->SetGridy();
17328  gPad->SetGridx();
17329  // gPad->SetLogy();
17330  if (kcountHEnegativedirectionReconoise2 == 1)
17331  HEnegativedirectionReconoise2->SetXTitle("R for HE- jeta =-29; depth = 2 \b");
17332  if (kcountHEnegativedirectionReconoise2 == 2)
17333  HEnegativedirectionReconoise2->SetXTitle("R for HE- jeta =-28; depth = 2 \b");
17334  if (kcountHEnegativedirectionReconoise2 == 3)
17335  HEnegativedirectionReconoise2->SetXTitle("R for HE- jeta =-27; depth = 2 \b");
17336  if (kcountHEnegativedirectionReconoise2 == 4)
17337  HEnegativedirectionReconoise2->SetXTitle("R for HE- jeta =-26; depth = 2 \b");
17338  if (kcountHEnegativedirectionReconoise2 == 5)
17339  HEnegativedirectionReconoise2->SetXTitle("R for HE- jeta =-25; depth = 2 \b");
17340  if (kcountHEnegativedirectionReconoise2 == 6)
17341  HEnegativedirectionReconoise2->SetXTitle("R for HE- jeta =-24; depth = 2 \b");
17342  if (kcountHEnegativedirectionReconoise2 == 7)
17343  HEnegativedirectionReconoise2->SetXTitle("R for HE- jeta =-23; depth = 2 \b");
17344  if (kcountHEnegativedirectionReconoise2 == 8)
17345  HEnegativedirectionReconoise2->SetXTitle("R for HE- jeta =-22; depth = 2 \b");
17346  if (kcountHEnegativedirectionReconoise2 == 9)
17347  HEnegativedirectionReconoise2->SetXTitle("R for HE- jeta =-21; depth = 2 \b");
17348  if (kcountHEnegativedirectionReconoise2 == 10)
17349  HEnegativedirectionReconoise2->SetXTitle("R for HE- jeta =-20; depth = 2 \b");
17350  if (kcountHEnegativedirectionReconoise2 == 11)
17351  HEnegativedirectionReconoise2->SetXTitle("R for HE- jeta =-19; depth = 2 \b");
17352  if (kcountHEnegativedirectionReconoise2 == 12)
17353  HEnegativedirectionReconoise2->SetXTitle("R for HE- jeta =-18; depth = 2 \b");
17354  if (kcountHEnegativedirectionReconoise2 == 13)
17355  HEnegativedirectionReconoise2->SetXTitle("R for HE- jeta =-17; depth = 2 \b");
17356  HEnegativedirectionReconoise2->Draw("Error");
17357  kcountHEnegativedirectionReconoise2++;
17358  if (kcountHEnegativedirectionReconoise2 > 13)
17359  break; // 4x6 = 24
17360  } //ccctest>0
17361 
17362  } // for i
17363  } //if(jeta-41 >= -29 && jeta-41 <= -16)
17364  } //for jeta
17366  c3x5->Update();
17367  c3x5->Print("RreconoiseNegativeDirectionhistD1PhiSymmetryDepth2HE.png");
17368  c3x5->Clear();
17369  // clean-up
17370  if (h2CeffHEnegativedirectionReconoise2)
17371  delete h2CeffHEnegativedirectionReconoise2;
17372  //========================================================================================== 1116
17373  //======================================================================
17374  //======================================================================1D plot: R vs phi , different eta, depth=3
17375  //cout<<" 1D plot: R vs phi , different eta, depth=3 *****" <<endl;
17376  c3x5->Clear();
17378  c3x5->Divide(3, 5);
17379  c3x5->cd(1);
17380  int kcountHEnegativedirectionReconoise3 = 1;
17381  TH1F *h2CeffHEnegativedirectionReconoise3 = new TH1F("h2CeffHEnegativedirectionReconoise3", "", nphi, 0., 72.);
17382  for (int jeta = 0; jeta < njeta; jeta++) {
17383  // negativedirectionReconoise:
17384  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
17385  // for (int i=0;i<ndepth;i++) {
17386  // depth=3
17387  for (int i = 2; i < 3; i++) {
17388  TH1F *HEnegativedirectionReconoise3 = (TH1F *)h2CeffHEnegativedirectionReconoise3->Clone("twod1");
17389  float ccctest = 0; // to avoid empty massive elements
17390  for (int jphi = 0; jphi < nphi; jphi++) {
17391  double ccc1 = areconoisehe[i][jeta][jphi];
17392  if (ccc1 != 0.) {
17393  HEnegativedirectionReconoise3->Fill(jphi, ccc1);
17394  ccctest = 1.; //HEnegativedirectionReconoise3->SetBinError(i,0.01);
17395  }
17396  } // for jphi
17397  if (ccctest > 0.) {
17398  //cout<<"666 kcountHEnegativedirectionReconoise3 = "<<kcountHEnegativedirectionReconoise3 <<" jeta-41= "<< jeta-41 <<endl;
17399  c3x5->cd(kcountHEnegativedirectionReconoise3);
17400  HEnegativedirectionReconoise3->SetMarkerStyle(20);
17401  HEnegativedirectionReconoise3->SetMarkerSize(0.4);
17402  HEnegativedirectionReconoise3->GetYaxis()->SetLabelSize(0.04);
17403  HEnegativedirectionReconoise3->SetXTitle("HEnegativedirectionReconoise3 \b");
17404  HEnegativedirectionReconoise3->SetMarkerColor(2);
17405  HEnegativedirectionReconoise3->SetLineColor(0);
17406  gPad->SetGridy();
17407  gPad->SetGridx();
17408  // gPad->SetLogy();
17409  if (kcountHEnegativedirectionReconoise3 == 1)
17410  HEnegativedirectionReconoise3->SetXTitle("R for HE- jeta =-29; depth = 3 \b");
17411  if (kcountHEnegativedirectionReconoise3 == 2)
17412  HEnegativedirectionReconoise3->SetXTitle("R for HE- jeta =-28; depth = 3 \b");
17413  if (kcountHEnegativedirectionReconoise3 == 3)
17414  HEnegativedirectionReconoise3->SetXTitle("R for HE- jeta =-27; depth = 3 \b");
17415  if (kcountHEnegativedirectionReconoise3 == 4)
17416  HEnegativedirectionReconoise3->SetXTitle("R for HE- jeta =-26; depth = 3 \b");
17417  if (kcountHEnegativedirectionReconoise3 == 5)
17418  HEnegativedirectionReconoise3->SetXTitle("R for HE- jeta =-25; depth = 3 \b");
17419  if (kcountHEnegativedirectionReconoise3 == 6)
17420  HEnegativedirectionReconoise3->SetXTitle("R for HE- jeta =-24; depth = 3 \b");
17421  if (kcountHEnegativedirectionReconoise3 == 7)
17422  HEnegativedirectionReconoise3->SetXTitle("R for HE- jeta =-23; depth = 3 \b");
17423  if (kcountHEnegativedirectionReconoise3 == 8)
17424  HEnegativedirectionReconoise3->SetXTitle("R for HE- jeta =-22; depth = 3 \b");
17425  if (kcountHEnegativedirectionReconoise3 == 9)
17426  HEnegativedirectionReconoise3->SetXTitle("R for HE- jeta =-21; depth = 3 \b");
17427  if (kcountHEnegativedirectionReconoise3 == 10)
17428  HEnegativedirectionReconoise3->SetXTitle("R for HE- jeta =-20; depth = 3 \b");
17429  if (kcountHEnegativedirectionReconoise3 == 11)
17430  HEnegativedirectionReconoise3->SetXTitle("R for HE- jeta =-19; depth = 3 \b");
17431  if (kcountHEnegativedirectionReconoise3 == 12)
17432  HEnegativedirectionReconoise3->SetXTitle("R for HE- jeta =-18; depth = 3 \b");
17433  if (kcountHEnegativedirectionReconoise3 == 13)
17434  HEnegativedirectionReconoise3->SetXTitle("R for HE- jeta =-17; depth = 3 \b");
17435  HEnegativedirectionReconoise3->Draw("Error");
17436  kcountHEnegativedirectionReconoise3++;
17437  if (kcountHEnegativedirectionReconoise3 > 13)
17438  break; // 4x6 = 24
17439  } //ccctest>0
17440 
17441  } // for i
17442  } //if(jeta-41 >= -29 && jeta-41 <= -16)
17443  } //for jeta
17445  c3x5->Update();
17446  c3x5->Print("RreconoiseNegativeDirectionhistD1PhiSymmetryDepth3HE.png");
17447  c3x5->Clear();
17448  // clean-up
17449  if (h2CeffHEnegativedirectionReconoise3)
17450  delete h2CeffHEnegativedirectionReconoise3;
17451  //========================================================================================== 1117
17452  //======================================================================
17453  //======================================================================1D plot: R vs phi , different eta, depth=4
17454  //cout<<" 1D plot: R vs phi , different eta, depth=4 *****" <<endl;
17455  c3x5->Clear();
17457  c3x5->Divide(3, 5);
17458  c3x5->cd(1);
17459  int kcountHEnegativedirectionReconoise4 = 1;
17460  TH1F *h2CeffHEnegativedirectionReconoise4 = new TH1F("h2CeffHEnegativedirectionReconoise4", "", nphi, 0., 72.);
17461 
17462  for (int jeta = 0; jeta < njeta; jeta++) {
17463  // negativedirectionReconoise:
17464  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
17465  // for (int i=0;i<ndepth;i++) {
17466  // depth=4
17467  for (int i = 3; i < 4; i++) {
17468  TH1F *HEnegativedirectionReconoise4 = (TH1F *)h2CeffHEnegativedirectionReconoise4->Clone("twod1");
17469 
17470  float ccctest = 0; // to avoid empty massive elements
17471  for (int jphi = 0; jphi < nphi; jphi++) {
17472  double ccc1 = areconoisehe[i][jeta][jphi];
17473  if (ccc1 != 0.) {
17474  HEnegativedirectionReconoise4->Fill(jphi, ccc1);
17475  ccctest = 1.; //HEnegativedirectionReconoise4->SetBinError(i,0.01);
17476  }
17477  } // for jphi
17478  if (ccctest > 0.) {
17479  //cout<<"777 kcountHEnegativedirectionReconoise4 = "<<kcountHEnegativedirectionReconoise4 <<" jeta-41= "<< jeta-41 <<endl;
17480  c3x5->cd(kcountHEnegativedirectionReconoise4);
17481  HEnegativedirectionReconoise4->SetMarkerStyle(20);
17482  HEnegativedirectionReconoise4->SetMarkerSize(0.4);
17483  HEnegativedirectionReconoise4->GetYaxis()->SetLabelSize(0.04);
17484  HEnegativedirectionReconoise4->SetXTitle("HEnegativedirectionReconoise4 \b");
17485  HEnegativedirectionReconoise4->SetMarkerColor(2);
17486  HEnegativedirectionReconoise4->SetLineColor(0);
17487  gPad->SetGridy();
17488  gPad->SetGridx();
17489  // gPad->SetLogy();
17490  if (kcountHEnegativedirectionReconoise4 == 1)
17491  HEnegativedirectionReconoise4->SetXTitle("R for HE- jeta =-28; depth = 4 \b");
17492  if (kcountHEnegativedirectionReconoise4 == 2)
17493  HEnegativedirectionReconoise4->SetXTitle("R for HE- jeta =-27; depth = 4 \b");
17494  if (kcountHEnegativedirectionReconoise4 == 3)
17495  HEnegativedirectionReconoise4->SetXTitle("R for HE- jeta =-26; depth = 4 \b");
17496  if (kcountHEnegativedirectionReconoise4 == 4)
17497  HEnegativedirectionReconoise4->SetXTitle("R for HE- jeta =-25; depth = 4 \b");
17498  if (kcountHEnegativedirectionReconoise4 == 5)
17499  HEnegativedirectionReconoise4->SetXTitle("R for HE- jeta =-24; depth = 4 \b");
17500  if (kcountHEnegativedirectionReconoise4 == 6)
17501  HEnegativedirectionReconoise4->SetXTitle("R for HE- jeta =-23; depth = 4 \b");
17502  if (kcountHEnegativedirectionReconoise4 == 7)
17503  HEnegativedirectionReconoise4->SetXTitle("R for HE- jeta =-22; depth = 4 \b");
17504  if (kcountHEnegativedirectionReconoise4 == 8)
17505  HEnegativedirectionReconoise4->SetXTitle("R for HE- jeta =-21; depth = 4 \b");
17506  if (kcountHEnegativedirectionReconoise4 == 9)
17507  HEnegativedirectionReconoise4->SetXTitle("R for HE- jeta =-20; depth = 4 \b");
17508  if (kcountHEnegativedirectionReconoise4 == 10)
17509  HEnegativedirectionReconoise4->SetXTitle("R for HE- jeta =-19; depth = 4 \b");
17510  if (kcountHEnegativedirectionReconoise4 == 11)
17511  HEnegativedirectionReconoise4->SetXTitle("R for HE- jeta =-18; depth = 4 \b");
17512  if (kcountHEnegativedirectionReconoise4 == 12)
17513  HEnegativedirectionReconoise4->SetXTitle("R for HE- jeta =-16; depth = 4 \b");
17514  HEnegativedirectionReconoise4->Draw("Error");
17515  kcountHEnegativedirectionReconoise4++;
17516  if (kcountHEnegativedirectionReconoise4 > 12)
17517  break; // 4x6 = 24
17518  } //ccctest>0
17519 
17520  } // for i
17521  } //if(jeta-41 >= -29 && jeta-41 <= -16)
17522  } //for jeta
17524  c3x5->Update();
17525  c3x5->Print("RreconoiseNegativeDirectionhistD1PhiSymmetryDepth4HE.png");
17526  c3x5->Clear();
17527  // clean-up
17528  if (h2CeffHEnegativedirectionReconoise4)
17529  delete h2CeffHEnegativedirectionReconoise4;
17530  //========================================================================================== 1118
17531  //======================================================================
17532  //======================================================================1D plot: R vs phi , different eta, depth=5
17533  //cout<<" 1D plot: R vs phi , different eta, depth=5 *****" <<endl;
17534  c3x5->Clear();
17536  c3x5->Divide(3, 5);
17537  c3x5->cd(1);
17538  int kcountHEnegativedirectionReconoise5 = 1;
17539  TH1F *h2CeffHEnegativedirectionReconoise5 = new TH1F("h2CeffHEnegativedirectionReconoise5", "", nphi, 0., 72.);
17540 
17541  for (int jeta = 0; jeta < njeta; jeta++) {
17542  // negativedirectionReconoise:
17543  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
17544  // for (int i=0;i<ndepth;i++) {
17545  // depth=5
17546  for (int i = 4; i < 5; i++) {
17547  TH1F *HEnegativedirectionReconoise5 = (TH1F *)h2CeffHEnegativedirectionReconoise5->Clone("twod1");
17548 
17549  float ccctest = 0; // to avoid empty massive elements
17550  for (int jphi = 0; jphi < nphi; jphi++) {
17551  // cout<<"888 initial kcountHEnegativedirectionReconoise5 = "<<kcountHEnegativedirectionReconoise5 <<" jeta-41= "<< jeta-41 <<" jphi= "<< jphi <<" areconoisehe[i][jeta][jphi]= "<< areconoisehe[i][jeta][jphi] <<" depth= "<< i <<endl;
17552 
17553  double ccc1 = areconoisehe[i][jeta][jphi];
17554  if (ccc1 != 0.) {
17555  HEnegativedirectionReconoise5->Fill(jphi, ccc1);
17556  ccctest = 1.; //HEnegativedirectionReconoise5->SetBinError(i,0.01);
17557  }
17558  } // for jphi
17559  if (ccctest > 0.) {
17560  //cout<<"888 kcountHEnegativedirectionReconoise5 = "<<kcountHEnegativedirectionReconoise5 <<" jeta-41= "<< jeta-41 <<endl;
17561  c3x5->cd(kcountHEnegativedirectionReconoise5);
17562  HEnegativedirectionReconoise5->SetMarkerStyle(20);
17563  HEnegativedirectionReconoise5->SetMarkerSize(0.4);
17564  HEnegativedirectionReconoise5->GetYaxis()->SetLabelSize(0.04);
17565  HEnegativedirectionReconoise5->SetXTitle("HEnegativedirectionReconoise5 \b");
17566  HEnegativedirectionReconoise5->SetMarkerColor(2);
17567  HEnegativedirectionReconoise5->SetLineColor(0);
17568  gPad->SetGridy();
17569  gPad->SetGridx();
17570  // gPad->SetLogy();
17571  if (kcountHEnegativedirectionReconoise5 == 1)
17572  HEnegativedirectionReconoise5->SetXTitle("R for HE- jeta =-28; depth = 5 \b");
17573  if (kcountHEnegativedirectionReconoise5 == 2)
17574  HEnegativedirectionReconoise5->SetXTitle("R for HE- jeta =-27; depth = 5 \b");
17575  if (kcountHEnegativedirectionReconoise5 == 3)
17576  HEnegativedirectionReconoise5->SetXTitle("R for HE- jeta =-26; depth = 5 \b");
17577  if (kcountHEnegativedirectionReconoise5 == 4)
17578  HEnegativedirectionReconoise5->SetXTitle("R for HE- jeta =-25; depth = 5 \b");
17579  if (kcountHEnegativedirectionReconoise5 == 5)
17580  HEnegativedirectionReconoise5->SetXTitle("R for HE- jeta =-24; depth = 5 \b");
17581  if (kcountHEnegativedirectionReconoise5 == 6)
17582  HEnegativedirectionReconoise5->SetXTitle("R for HE- jeta =-23; depth = 5 \b");
17583  if (kcountHEnegativedirectionReconoise5 == 7)
17584  HEnegativedirectionReconoise5->SetXTitle("R for HE- jeta =-22; depth = 5 \b");
17585  if (kcountHEnegativedirectionReconoise5 == 8)
17586  HEnegativedirectionReconoise5->SetXTitle("R for HE- jeta =-21; depth = 5 \b");
17587  if (kcountHEnegativedirectionReconoise5 == 9)
17588  HEnegativedirectionReconoise5->SetXTitle("R for HE- jeta =-20; depth = 5 \b");
17589  if (kcountHEnegativedirectionReconoise5 == 10)
17590  HEnegativedirectionReconoise5->SetXTitle("R for HE- jeta =-19; depth = 5 \b");
17591  if (kcountHEnegativedirectionReconoise5 == 11)
17592  HEnegativedirectionReconoise5->SetXTitle("R for HE- jeta =-18; depth = 5 \b");
17593  HEnegativedirectionReconoise5->Draw("Error");
17594  kcountHEnegativedirectionReconoise5++;
17595  if (kcountHEnegativedirectionReconoise5 > 11)
17596  break; // 4x6 = 24
17597  } //ccctest>0
17598 
17599  } // for i
17600  } //if(jeta-41 >= -29 && jeta-41 <= -16)
17601  } //for jeta
17603  c3x5->Update();
17604  c3x5->Print("RreconoiseNegativeDirectionhistD1PhiSymmetryDepth5HE.png");
17605  c3x5->Clear();
17606  // clean-up
17607  if (h2CeffHEnegativedirectionReconoise5)
17608  delete h2CeffHEnegativedirectionReconoise5;
17609  //========================================================================================== 1119
17610  //======================================================================
17611  //======================================================================1D plot: R vs phi , different eta, depth=6
17612  //cout<<" 1D plot: R vs phi , different eta, depth=6 *****" <<endl;
17613  c3x5->Clear();
17615  c3x5->Divide(3, 5);
17616  c3x5->cd(1);
17617  int kcountHEnegativedirectionReconoise6 = 1;
17618  TH1F *h2CeffHEnegativedirectionReconoise6 = new TH1F("h2CeffHEnegativedirectionReconoise6", "", nphi, 0., 72.);
17619 
17620  for (int jeta = 0; jeta < njeta; jeta++) {
17621  // negativedirectionReconoise:
17622  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
17623  // for (int i=0;i<ndepth;i++) {
17624  // depth=6
17625  for (int i = 5; i < 6; i++) {
17626  TH1F *HEnegativedirectionReconoise6 = (TH1F *)h2CeffHEnegativedirectionReconoise6->Clone("twod1");
17627 
17628  float ccctest = 0; // to avoid empty massive elements
17629  for (int jphi = 0; jphi < nphi; jphi++) {
17630  double ccc1 = areconoisehe[i][jeta][jphi];
17631  if (ccc1 != 0.) {
17632  HEnegativedirectionReconoise6->Fill(jphi, ccc1);
17633  ccctest = 1.; //HEnegativedirectionReconoise6->SetBinError(i,0.01);
17634  }
17635  } // for jphi
17636  if (ccctest > 0.) {
17637  //cout<<"999 kcountHEnegativedirectionReconoise6 = "<<kcountHEnegativedirectionReconoise6 <<" jeta-41= "<< jeta-41 <<endl;
17638  c3x5->cd(kcountHEnegativedirectionReconoise6);
17639  HEnegativedirectionReconoise6->SetMarkerStyle(20);
17640  HEnegativedirectionReconoise6->SetMarkerSize(0.4);
17641  HEnegativedirectionReconoise6->GetYaxis()->SetLabelSize(0.04);
17642  HEnegativedirectionReconoise6->SetXTitle("HEnegativedirectionReconoise6 \b");
17643  HEnegativedirectionReconoise6->SetMarkerColor(2);
17644  HEnegativedirectionReconoise6->SetLineColor(0);
17645  gPad->SetGridy();
17646  gPad->SetGridx();
17647  // gPad->SetLogy();
17648  if (kcountHEnegativedirectionReconoise6 == 1)
17649  HEnegativedirectionReconoise6->SetXTitle("R for HE- jeta =-28; depth = 6 \b");
17650  if (kcountHEnegativedirectionReconoise6 == 2)
17651  HEnegativedirectionReconoise6->SetXTitle("R for HE- jeta =-27; depth = 6 \b");
17652  if (kcountHEnegativedirectionReconoise6 == 3)
17653  HEnegativedirectionReconoise6->SetXTitle("R for HE- jeta =-26; depth = 6 \b");
17654  if (kcountHEnegativedirectionReconoise6 == 4)
17655  HEnegativedirectionReconoise6->SetXTitle("R for HE- jeta =-25; depth = 6 \b");
17656  if (kcountHEnegativedirectionReconoise6 == 5)
17657  HEnegativedirectionReconoise6->SetXTitle("R for HE- jeta =-24; depth = 6 \b");
17658  if (kcountHEnegativedirectionReconoise6 == 6)
17659  HEnegativedirectionReconoise6->SetXTitle("R for HE- jeta =-23; depth = 6 \b");
17660  if (kcountHEnegativedirectionReconoise6 == 7)
17661  HEnegativedirectionReconoise6->SetXTitle("R for HE- jeta =-22; depth = 6 \b");
17662  if (kcountHEnegativedirectionReconoise6 == 8)
17663  HEnegativedirectionReconoise6->SetXTitle("R for HE- jeta =-21; depth = 6 \b");
17664  if (kcountHEnegativedirectionReconoise6 == 9)
17665  HEnegativedirectionReconoise6->SetXTitle("R for HE- jeta =-20; depth = 6 \b");
17666  if (kcountHEnegativedirectionReconoise6 == 10)
17667  HEnegativedirectionReconoise6->SetXTitle("R for HE- jeta =-19; depth = 6 \b");
17668  HEnegativedirectionReconoise6->Draw("Error");
17669  kcountHEnegativedirectionReconoise6++;
17670  if (kcountHEnegativedirectionReconoise6 > 10)
17671  break; // 4x6 = 24
17672  } //ccctest>0
17673 
17674  } // for i
17675  } //if(jeta-41 >= -29 && jeta-41 <= -16)
17676  } //for jeta
17678  c3x5->Update();
17679  c3x5->Print("RreconoiseNegativeDirectionhistD1PhiSymmetryDepth6HE.png");
17680  c3x5->Clear();
17681  // clean-up
17682  if (h2CeffHEnegativedirectionReconoise6)
17683  delete h2CeffHEnegativedirectionReconoise6;
17684  //========================================================================================== 11110
17685  //======================================================================
17686  //======================================================================1D plot: R vs phi , different eta, depth=7
17687  //cout<<" 1D plot: R vs phi , different eta, depth=7 *****" <<endl;
17688  c3x5->Clear();
17690  c3x5->Divide(3, 5);
17691  c3x5->cd(1);
17692  int kcountHEnegativedirectionReconoise7 = 1;
17693  TH1F *h2CeffHEnegativedirectionReconoise7 = new TH1F("h2CeffHEnegativedirectionReconoise7", "", nphi, 0., 72.);
17694 
17695  for (int jeta = 0; jeta < njeta; jeta++) {
17696  // negativedirectionReconoise:
17697  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
17698  // for (int i=0;i<ndepth;i++) {
17699  // depth=7
17700  for (int i = 6; i < 7; i++) {
17701  TH1F *HEnegativedirectionReconoise7 = (TH1F *)h2CeffHEnegativedirectionReconoise7->Clone("twod1");
17702 
17703  float ccctest = 0; // to avoid empty massive elements
17704  for (int jphi = 0; jphi < nphi; jphi++) {
17705  double ccc1 = areconoisehe[i][jeta][jphi];
17706  if (ccc1 != 0.) {
17707  HEnegativedirectionReconoise7->Fill(jphi, ccc1);
17708  ccctest = 1.; //HEnegativedirectionReconoise7->SetBinError(i,0.01);
17709  }
17710  } // for jphi
17711  if (ccctest > 0.) {
17712  //cout<<"1010 kcountHEnegativedirectionReconoise7 = "<<kcountHEnegativedirectionReconoise7 <<" jeta-41= "<< jeta-41 <<endl;
17713  c3x5->cd(kcountHEnegativedirectionReconoise7);
17714  HEnegativedirectionReconoise7->SetMarkerStyle(20);
17715  HEnegativedirectionReconoise7->SetMarkerSize(0.4);
17716  HEnegativedirectionReconoise7->GetYaxis()->SetLabelSize(0.04);
17717  HEnegativedirectionReconoise7->SetXTitle("HEnegativedirectionReconoise7 \b");
17718  HEnegativedirectionReconoise7->SetMarkerColor(2);
17719  HEnegativedirectionReconoise7->SetLineColor(0);
17720  gPad->SetGridy();
17721  gPad->SetGridx();
17722  // gPad->SetLogy();
17723  if (kcountHEnegativedirectionReconoise7 == 1)
17724  HEnegativedirectionReconoise7->SetXTitle("R for HE- jeta =-28; depth = 7 \b");
17725  if (kcountHEnegativedirectionReconoise7 == 2)
17726  HEnegativedirectionReconoise7->SetXTitle("R for HE- jeta =-27; depth = 7 \b");
17727  if (kcountHEnegativedirectionReconoise7 == 3)
17728  HEnegativedirectionReconoise7->SetXTitle("R for HE- jeta =-26; depth = 7 \b");
17729  HEnegativedirectionReconoise7->Draw("Error");
17730  kcountHEnegativedirectionReconoise7++;
17731  if (kcountHEnegativedirectionReconoise7 > 3)
17732  break; // 4x6 = 24
17733  } //ccctest>0
17734 
17735  } // for i
17736  } //if(jeta-41 >= -29 && jeta-41 <= -16)
17737  } //for jeta
17739  c3x5->Update();
17740  c3x5->Print("RreconoiseNegativeDirectionhistD1PhiSymmetryDepth7HE.png");
17741  c3x5->Clear();
17742  // clean-up
17743  if (h2CeffHEnegativedirectionReconoise7)
17744  delete h2CeffHEnegativedirectionReconoise7;
17745 
17746  //======================================================================================================================
17747  //======================================================================================================================
17749  //======================================================================================================================
17750  // DIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIF: Reconoise HE
17751  //======================================================================================================================
17752  //======================================================================
17753  c2x1->Clear();
17755  c2x1->Divide(2, 1);
17756  c2x1->cd(1);
17757  TH2F *GefzDIFreconoiseHE42D = new TH2F("GefzDIFreconoiseHE42D", "", neta, -41., 41., nphi, 0., 72.);
17758  TH2F *GefzDIFreconoiseHE42D0 = new TH2F("GefzDIFreconoiseHE42D0", "", neta, -41., 41., nphi, 0., 72.);
17759  TH2F *GefzDIFreconoiseHE42DF = (TH2F *)GefzDIFreconoiseHE42D0->Clone("GefzDIFreconoiseHE42DF");
17760  for (int i = 0; i < ndepth; i++) {
17761  for (int jeta = 0; jeta < neta; jeta++) {
17762  if ((jeta - 41 >= -29 && jeta - 41 <= -16) || (jeta - 41 >= 15 && jeta - 41 <= 28)) {
17763  for (int jphi = 0; jphi < nphi; jphi++) {
17764  double ccc1 = breconoisehe[i][jeta][jphi];
17765  int k2plot = jeta - 41;
17766  int kkk = k2plot; //if(k2plot >0 ) kkk=k2plot+1; //-41 +41 !=0
17767  if (ccc1 != 0.) {
17768  GefzDIFreconoiseHE42D->Fill(kkk, jphi, ccc1);
17769  GefzDIFreconoiseHE42D0->Fill(kkk, jphi, 1.);
17770  }
17771  }
17772  }
17773  }
17774  }
17775  GefzDIFreconoiseHE42DF->Divide(GefzDIFreconoiseHE42D, GefzDIFreconoiseHE42D0, 1, 1, "B"); // average A
17776  gPad->SetGridy();
17777  gPad->SetGridx(); // gPad->SetLogz();
17778  GefzDIFreconoiseHE42DF->SetXTitle("<DIF>_depth #eta \b");
17779  GefzDIFreconoiseHE42DF->SetYTitle(" #phi \b");
17780  GefzDIFreconoiseHE42DF->Draw("COLZ");
17781 
17782  //c2x1->cd(2);
17783  //TH1F *energyhitNoise_HE= (TH1F*)dir->FindObjectAny("h_energyhitNoise_HE");
17784  //energyhitNoise_HE ->SetMarkerStyle(20);energyhitNoise_HE ->SetMarkerSize(0.4);energyhitNoise_HE ->GetYaxis()->SetLabelSize(0.04);energyhitNoise_HE ->SetXTitle("energyhitNoise_HE \b");energyhitNoise_HE ->SetMarkerColor(2);energyhitNoise_HE ->SetLineColor(0);gPad->SetGridy();gPad->SetGridx();energyhitNoise_HE ->Draw("Error");
17785 
17787  c2x1->Update();
17788  c2x1->Print("DIFreconoiseGeneralD2PhiSymmetryHE.png");
17789  c2x1->Clear();
17790  // clean-up
17791  if (GefzDIFreconoiseHE42D)
17792  delete GefzDIFreconoiseHE42D;
17793  if (GefzDIFreconoiseHE42D0)
17794  delete GefzDIFreconoiseHE42D0;
17795  if (GefzDIFreconoiseHE42DF)
17796  delete GefzDIFreconoiseHE42DF;
17797  //====================================================================== 1D plot: DIF vs phi , averaged over depthes & eta
17798  //======================================================================
17799  //cout<<" 1D plot: DIF vs phi , averaged over depthes & eta *****" <<endl;
17800  c1x1->Clear();
17802  c1x1->Divide(1, 1);
17803  c1x1->cd(1);
17804  TH1F *GefzDIFreconoiseHE41D = new TH1F("GefzDIFreconoiseHE41D", "", nphi, 0., 72.);
17805  TH1F *GefzDIFreconoiseHE41D0 = new TH1F("GefzDIFreconoiseHE41D0", "", nphi, 0., 72.);
17806  TH1F *GefzDIFreconoiseHE41DF = (TH1F *)GefzDIFreconoiseHE41D0->Clone("GefzDIFreconoiseHE41DF");
17807  for (int jphi = 0; jphi < nphi; jphi++) {
17808  for (int jeta = 0; jeta < neta; jeta++) {
17809  if ((jeta - 41 >= -29 && jeta - 41 <= -16) || (jeta - 41 >= 15 && jeta - 41 <= 28)) {
17810  for (int i = 0; i < ndepth; i++) {
17811  double ccc1 = breconoisehe[i][jeta][jphi];
17812  if (ccc1 != 0.) {
17813  GefzDIFreconoiseHE41D->Fill(jphi, ccc1);
17814  GefzDIFreconoiseHE41D0->Fill(jphi, 1.);
17815  }
17816  }
17817  }
17818  }
17819  }
17820  GefzDIFreconoiseHE41DF->Divide(
17821  GefzDIFreconoiseHE41D, GefzDIFreconoiseHE41D0, 1, 1, "B"); // DIF averaged over depthes & eta
17822  GefzDIFreconoiseHE41D0->Sumw2();
17823  // for (int jphi=1;jphi<73;jphi++) {GefzDIFreconoiseHE41DF->SetBinError(jphi,0.01);}
17824  gPad->SetGridy();
17825  gPad->SetGridx(); // gPad->SetLogz();
17826  GefzDIFreconoiseHE41DF->SetMarkerStyle(20);
17827  GefzDIFreconoiseHE41DF->SetMarkerSize(1.4);
17828  GefzDIFreconoiseHE41DF->GetZaxis()->SetLabelSize(0.08);
17829  GefzDIFreconoiseHE41DF->SetXTitle("#phi \b");
17830  GefzDIFreconoiseHE41DF->SetYTitle(" <DIF> \b");
17831  GefzDIFreconoiseHE41DF->SetZTitle("<DIF>_PHI - AllDepthes \b");
17832  GefzDIFreconoiseHE41DF->SetMarkerColor(4);
17833  GefzDIFreconoiseHE41DF->SetLineColor(
17834  4); // GefzDIFreconoiseHE41DF->SetMinimum(0.8); // GefzDIFreconoiseHE41DF->SetMaximum(1.000);
17835  GefzDIFreconoiseHE41DF->Draw("Error");
17837  c1x1->Update();
17838  c1x1->Print("DIFreconoiseGeneralD1PhiSymmetryHE.png");
17839  c1x1->Clear();
17840  // clean-up
17841  if (GefzDIFreconoiseHE41D)
17842  delete GefzDIFreconoiseHE41D;
17843  if (GefzDIFreconoiseHE41D0)
17844  delete GefzDIFreconoiseHE41D0;
17845  if (GefzDIFreconoiseHE41DF)
17846  delete GefzDIFreconoiseHE41DF;
17847 
17848  //========================================================================================== 4
17849  //======================================================================
17850  //======================================================================1D plot: DIF vs phi , different eta, depth=1
17851  //cout<<" 1D plot: DIF vs phi , different eta, depth=1 *****" <<endl;
17852  c3x5->Clear();
17854  c3x5->Divide(3, 5);
17855  c3x5->cd(1);
17856  int kcountHEpositivedirectionReconoiseDIF1 = 1;
17857  TH1F *h2CeffHEpositivedirectionReconoiseDIF1 = new TH1F("h2CeffHEpositivedirectionReconoiseDIF1", "", nphi, 0., 72.);
17858  for (int jeta = 0; jeta < njeta; jeta++) {
17859  // positivedirectionReconoiseDIF:
17860  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
17861  // for (int i=0;i<ndepth;i++) {
17862  // depth=1
17863  for (int i = 0; i < 1; i++) {
17864  TH1F *HEpositivedirectionReconoiseDIF1 = (TH1F *)h2CeffHEpositivedirectionReconoiseDIF1->Clone("twod1");
17865  float ccctest = 0; // to avoid empty massive elements
17866  for (int jphi = 0; jphi < nphi; jphi++) {
17867  double ccc1 = breconoisehe[i][jeta][jphi];
17868  if (ccc1 != 0.) {
17869  HEpositivedirectionReconoiseDIF1->Fill(jphi, ccc1);
17870  ccctest = 1.; //HEpositivedirectionReconoiseDIF1->SetBinError(i,0.01);
17871  }
17872  } // for jphi
17873  if (ccctest > 0.) {
17874  // cout<<"444 kcountHEpositivedirectionReconoiseDIF1 = "<<kcountHEpositivedirectionReconoiseDIF1 <<" jeta-41= "<< jeta-41 <<endl;
17875  c3x5->cd(kcountHEpositivedirectionReconoiseDIF1);
17876  HEpositivedirectionReconoiseDIF1->SetMarkerStyle(20);
17877  HEpositivedirectionReconoiseDIF1->SetMarkerSize(0.4);
17878  HEpositivedirectionReconoiseDIF1->GetYaxis()->SetLabelSize(0.04);
17879  HEpositivedirectionReconoiseDIF1->SetXTitle("HEpositivedirectionReconoiseDIF1 \b");
17880  HEpositivedirectionReconoiseDIF1->SetMarkerColor(2);
17881  HEpositivedirectionReconoiseDIF1->SetLineColor(0);
17882  gPad->SetGridy();
17883  gPad->SetGridx();
17884  // gPad->SetLogy();
17885  if (kcountHEpositivedirectionReconoiseDIF1 == 1)
17886  HEpositivedirectionReconoiseDIF1->SetXTitle("DIF for HE+ jeta = 17; depth = 1 \b");
17887  if (kcountHEpositivedirectionReconoiseDIF1 == 2)
17888  HEpositivedirectionReconoiseDIF1->SetXTitle("DIF for HE+ jeta = 18; depth = 1 \b");
17889  if (kcountHEpositivedirectionReconoiseDIF1 == 3)
17890  HEpositivedirectionReconoiseDIF1->SetXTitle("DIF for HE+ jeta = 19; depth = 1 \b");
17891  if (kcountHEpositivedirectionReconoiseDIF1 == 4)
17892  HEpositivedirectionReconoiseDIF1->SetXTitle("DIF for HE+ jeta = 20; depth = 1 \b");
17893  if (kcountHEpositivedirectionReconoiseDIF1 == 5)
17894  HEpositivedirectionReconoiseDIF1->SetXTitle("DIF for HE+ jeta = 21; depth = 1 \b");
17895  if (kcountHEpositivedirectionReconoiseDIF1 == 6)
17896  HEpositivedirectionReconoiseDIF1->SetXTitle("DIF for HE+ jeta = 22; depth = 1 \b");
17897  if (kcountHEpositivedirectionReconoiseDIF1 == 7)
17898  HEpositivedirectionReconoiseDIF1->SetXTitle("DIF for HE+ jeta = 23; depth = 1 \b");
17899  if (kcountHEpositivedirectionReconoiseDIF1 == 8)
17900  HEpositivedirectionReconoiseDIF1->SetXTitle("DIF for HE+ jeta = 24; depth = 1 \b");
17901  if (kcountHEpositivedirectionReconoiseDIF1 == 9)
17902  HEpositivedirectionReconoiseDIF1->SetXTitle("DIF for HE+ jeta = 25; depth = 1 \b");
17903  if (kcountHEpositivedirectionReconoiseDIF1 == 10)
17904  HEpositivedirectionReconoiseDIF1->SetXTitle("DIF for HE+ jeta = 26; depth = 1 \b");
17905  if (kcountHEpositivedirectionReconoiseDIF1 == 11)
17906  HEpositivedirectionReconoiseDIF1->SetXTitle("DIF for HE+ jeta = 27; depth = 1 \b");
17907  if (kcountHEpositivedirectionReconoiseDIF1 == 12)
17908  HEpositivedirectionReconoiseDIF1->SetXTitle("DIF for HE+ jeta = 28; depth = 1 \b");
17909  HEpositivedirectionReconoiseDIF1->Draw("Error");
17910  kcountHEpositivedirectionReconoiseDIF1++;
17911  if (kcountHEpositivedirectionReconoiseDIF1 > 12)
17912  break; // 4x6 = 24
17913  } //ccctest>0
17914 
17915  } // for i
17916  } //if(jeta-41 >= 15 && jeta-41 <= 28
17917  } //for jeta
17919  c3x5->Update();
17920  c3x5->Print("DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth1HE.png");
17921  c3x5->Clear();
17922  // clean-up
17923  if (h2CeffHEpositivedirectionReconoiseDIF1)
17924  delete h2CeffHEpositivedirectionReconoiseDIF1;
17925 
17926  //========================================================================================== 5
17927  //======================================================================
17928  //======================================================================1D plot: R vs phi , different eta, depth=2
17929  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
17930  c3x5->Clear();
17932  c3x5->Divide(3, 5);
17933  c3x5->cd(1);
17934  int kcountHEpositivedirectionReconoiseDIF2 = 1;
17935  TH1F *h2CeffHEpositivedirectionReconoiseDIF2 = new TH1F("h2CeffHEpositivedirectionReconoiseDIF2", "", nphi, 0., 72.);
17936  for (int jeta = 0; jeta < njeta; jeta++) {
17937  // positivedirectionReconoiseDIF:
17938  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
17939  // for (int i=0;i<ndepth;i++) {
17940  // depth=2
17941  for (int i = 1; i < 2; i++) {
17942  TH1F *HEpositivedirectionReconoiseDIF2 = (TH1F *)h2CeffHEpositivedirectionReconoiseDIF2->Clone("twod1");
17943  float ccctest = 0; // to avoid empty massive elements
17944  for (int jphi = 0; jphi < nphi; jphi++) {
17945  double ccc1 = breconoisehe[i][jeta][jphi];
17946  if (ccc1 != 0.) {
17947  HEpositivedirectionReconoiseDIF2->Fill(jphi, ccc1);
17948  ccctest = 1.; //HEpositivedirectionReconoiseDIF2->SetBinError(i,0.01);
17949  }
17950  } // for jphi
17951  if (ccctest > 0.) {
17952  //cout<<"555 kcountHEpositivedirectionReconoiseDIF2 = "<<kcountHEpositivedirectionReconoiseDIF2 <<" jeta-41= "<< jeta-41 <<endl;
17953  c3x5->cd(kcountHEpositivedirectionReconoiseDIF2);
17954  HEpositivedirectionReconoiseDIF2->SetMarkerStyle(20);
17955  HEpositivedirectionReconoiseDIF2->SetMarkerSize(0.4);
17956  HEpositivedirectionReconoiseDIF2->GetYaxis()->SetLabelSize(0.04);
17957  HEpositivedirectionReconoiseDIF2->SetXTitle("HEpositivedirectionReconoiseDIF2 \b");
17958  HEpositivedirectionReconoiseDIF2->SetMarkerColor(2);
17959  HEpositivedirectionReconoiseDIF2->SetLineColor(0);
17960  gPad->SetGridy();
17961  gPad->SetGridx();
17962  // gPad->SetLogy();
17963  if (kcountHEpositivedirectionReconoiseDIF2 == 1)
17964  HEpositivedirectionReconoiseDIF2->SetXTitle("DIF for HE+ jeta = 16; depth = 2 \b");
17965  if (kcountHEpositivedirectionReconoiseDIF2 == 2)
17966  HEpositivedirectionReconoiseDIF2->SetXTitle("DIF for HE+ jeta = 17; depth = 2 \b");
17967  if (kcountHEpositivedirectionReconoiseDIF2 == 3)
17968  HEpositivedirectionReconoiseDIF2->SetXTitle("DIF for HE+ jeta = 18; depth = 2 \b");
17969  if (kcountHEpositivedirectionReconoiseDIF2 == 4)
17970  HEpositivedirectionReconoiseDIF2->SetXTitle("DIF for HE+ jeta = 19; depth = 2 \b");
17971  if (kcountHEpositivedirectionReconoiseDIF2 == 5)
17972  HEpositivedirectionReconoiseDIF2->SetXTitle("DIF for HE+ jeta = 20; depth = 2 \b");
17973  if (kcountHEpositivedirectionReconoiseDIF2 == 6)
17974  HEpositivedirectionReconoiseDIF2->SetXTitle("DIF for HE+ jeta = 21; depth = 2 \b");
17975  if (kcountHEpositivedirectionReconoiseDIF2 == 7)
17976  HEpositivedirectionReconoiseDIF2->SetXTitle("DIF for HE+ jeta = 22; depth = 2 \b");
17977  if (kcountHEpositivedirectionReconoiseDIF2 == 8)
17978  HEpositivedirectionReconoiseDIF2->SetXTitle("DIF for HE+ jeta = 23; depth = 2 \b");
17979  if (kcountHEpositivedirectionReconoiseDIF2 == 9)
17980  HEpositivedirectionReconoiseDIF2->SetXTitle("DIF for HE+ jeta = 24; depth = 2 \b");
17981  if (kcountHEpositivedirectionReconoiseDIF2 == 10)
17982  HEpositivedirectionReconoiseDIF2->SetXTitle("DIF for HE+ jeta = 25; depth = 2 \b");
17983  if (kcountHEpositivedirectionReconoiseDIF2 == 11)
17984  HEpositivedirectionReconoiseDIF2->SetXTitle("DIF for HE+ jeta = 26; depth = 2 \b");
17985  if (kcountHEpositivedirectionReconoiseDIF2 == 12)
17986  HEpositivedirectionReconoiseDIF2->SetXTitle("DIF for HE+ jeta = 27; depth = 2 \b");
17987  if (kcountHEpositivedirectionReconoiseDIF2 == 13)
17988  HEpositivedirectionReconoiseDIF2->SetXTitle("DIF for HE+ jeta = 28; depth = 2 \b");
17989  HEpositivedirectionReconoiseDIF2->Draw("Error");
17990  kcountHEpositivedirectionReconoiseDIF2++;
17991  if (kcountHEpositivedirectionReconoiseDIF2 > 13)
17992  break; // 4x6 = 24
17993  } //ccctest>0
17994 
17995  } // for i
17996  } //if(jeta-41
17997  } //for jeta
17999  c3x5->Update();
18000  c3x5->Print("DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth2HE.png");
18001  c3x5->Clear();
18002  // clean-up
18003  if (h2CeffHEpositivedirectionReconoiseDIF2)
18004  delete h2CeffHEpositivedirectionReconoiseDIF2;
18005  //========================================================================================== 6
18006  //======================================================================
18007  //======================================================================1D plot: R vs phi , different eta, depth=3
18008  //cout<<" 1D plot: R vs phi , different eta, depth=3 *****" <<endl;
18009  c3x5->Clear();
18011  c3x5->Divide(3, 5);
18012  c3x5->cd(1);
18013  int kcountHEpositivedirectionReconoiseDIF3 = 1;
18014  TH1F *h2CeffHEpositivedirectionReconoiseDIF3 = new TH1F("h2CeffHEpositivedirectionReconoiseDIF3", "", nphi, 0., 72.);
18015  for (int jeta = 0; jeta < njeta; jeta++) {
18016  // positivedirectionReconoiseDIF:
18017  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
18018  // for (int i=0;i<ndepth;i++) {
18019  // depth=3
18020  for (int i = 2; i < 3; i++) {
18021  TH1F *HEpositivedirectionReconoiseDIF3 = (TH1F *)h2CeffHEpositivedirectionReconoiseDIF3->Clone("twod1");
18022  float ccctest = 0; // to avoid empty massive elements
18023  for (int jphi = 0; jphi < nphi; jphi++) {
18024  double ccc1 = breconoisehe[i][jeta][jphi];
18025  if (ccc1 != 0.) {
18026  HEpositivedirectionReconoiseDIF3->Fill(jphi, ccc1);
18027  ccctest = 1.; //HEpositivedirectionReconoiseDIF3->SetBinError(i,0.01);
18028  }
18029  } // for jphi
18030  if (ccctest > 0.) {
18031  //cout<<"666 kcountHEpositivedirectionReconoiseDIF3 = "<<kcountHEpositivedirectionReconoiseDIF3 <<" jeta-41= "<< jeta-41 <<endl;
18032  c3x5->cd(kcountHEpositivedirectionReconoiseDIF3);
18033  HEpositivedirectionReconoiseDIF3->SetMarkerStyle(20);
18034  HEpositivedirectionReconoiseDIF3->SetMarkerSize(0.4);
18035  HEpositivedirectionReconoiseDIF3->GetYaxis()->SetLabelSize(0.04);
18036  HEpositivedirectionReconoiseDIF3->SetXTitle("HEpositivedirectionReconoiseDIF3 \b");
18037  HEpositivedirectionReconoiseDIF3->SetMarkerColor(2);
18038  HEpositivedirectionReconoiseDIF3->SetLineColor(0);
18039  gPad->SetGridy();
18040  gPad->SetGridx();
18041  // gPad->SetLogy();
18042  if (kcountHEpositivedirectionReconoiseDIF3 == 1)
18043  HEpositivedirectionReconoiseDIF3->SetXTitle("DIF for HE+ jeta = 16; depth = 3 \b");
18044  if (kcountHEpositivedirectionReconoiseDIF3 == 2)
18045  HEpositivedirectionReconoiseDIF3->SetXTitle("DIF for HE+ jeta = 17; depth = 3 \b");
18046  if (kcountHEpositivedirectionReconoiseDIF3 == 3)
18047  HEpositivedirectionReconoiseDIF3->SetXTitle("DIF for HE+ jeta = 18; depth = 3 \b");
18048  if (kcountHEpositivedirectionReconoiseDIF3 == 4)
18049  HEpositivedirectionReconoiseDIF3->SetXTitle("DIF for HE+ jeta = 19; depth = 3 \b");
18050  if (kcountHEpositivedirectionReconoiseDIF3 == 5)
18051  HEpositivedirectionReconoiseDIF3->SetXTitle("DIF for HE+ jeta = 20; depth = 3 \b");
18052  if (kcountHEpositivedirectionReconoiseDIF3 == 6)
18053  HEpositivedirectionReconoiseDIF3->SetXTitle("DIF for HE+ jeta = 21; depth = 3 \b");
18054  if (kcountHEpositivedirectionReconoiseDIF3 == 7)
18055  HEpositivedirectionReconoiseDIF3->SetXTitle("DIF for HE+ jeta = 22; depth = 3 \b");
18056  if (kcountHEpositivedirectionReconoiseDIF3 == 8)
18057  HEpositivedirectionReconoiseDIF3->SetXTitle("DIF for HE+ jeta = 23; depth = 3 \b");
18058  if (kcountHEpositivedirectionReconoiseDIF3 == 9)
18059  HEpositivedirectionReconoiseDIF3->SetXTitle("DIF for HE+ jeta = 24; depth = 3 \b");
18060  if (kcountHEpositivedirectionReconoiseDIF3 == 10)
18061  HEpositivedirectionReconoiseDIF3->SetXTitle("DIF for HE+ jeta = 25; depth = 3 \b");
18062  if (kcountHEpositivedirectionReconoiseDIF3 == 11)
18063  HEpositivedirectionReconoiseDIF3->SetXTitle("DIF for HE+ jeta = 26; depth = 3 \b");
18064  if (kcountHEpositivedirectionReconoiseDIF3 == 12)
18065  HEpositivedirectionReconoiseDIF3->SetXTitle("DIF for HE+ jeta = 27; depth = 3 \b");
18066  if (kcountHEpositivedirectionReconoiseDIF3 == 13)
18067  HEpositivedirectionReconoiseDIF3->SetXTitle("DIF for HE+ jeta = 28; depth = 3 \b");
18068  HEpositivedirectionReconoiseDIF3->Draw("Error");
18069  kcountHEpositivedirectionReconoiseDIF3++;
18070  if (kcountHEpositivedirectionReconoiseDIF3 > 13)
18071  break; // 4x6 = 24
18072  } //ccctest>0
18073 
18074  } // for i
18075  } //if(jeta-41 >=
18076  } //for jeta
18078  c3x5->Update();
18079  c3x5->Print("DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth3HE.png");
18080  c3x5->Clear();
18081  // clean-up
18082  if (h2CeffHEpositivedirectionReconoiseDIF3)
18083  delete h2CeffHEpositivedirectionReconoiseDIF3;
18084  //========================================================================================== 7
18085  //======================================================================
18086  //======================================================================1D plot: R vs phi , different eta, depth=4
18087  //cout<<" 1D plot: R vs phi , different eta, depth=4 *****" <<endl;
18088  c3x5->Clear();
18090  c3x5->Divide(3, 5);
18091  c3x5->cd(1);
18092  int kcountHEpositivedirectionReconoiseDIF4 = 1;
18093  TH1F *h2CeffHEpositivedirectionReconoiseDIF4 = new TH1F("h2CeffHEpositivedirectionReconoiseDIF4", "", nphi, 0., 72.);
18094 
18095  for (int jeta = 0; jeta < njeta; jeta++) {
18096  // positivedirectionReconoiseDIF:
18097  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
18098  // for (int i=0;i<ndepth;i++) {
18099  // depth=4
18100  for (int i = 3; i < 4; i++) {
18101  TH1F *HEpositivedirectionReconoiseDIF4 = (TH1F *)h2CeffHEpositivedirectionReconoiseDIF4->Clone("twod1");
18102 
18103  float ccctest = 0; // to avoid empty massive elements
18104  for (int jphi = 0; jphi < nphi; jphi++) {
18105  double ccc1 = breconoisehe[i][jeta][jphi];
18106  if (ccc1 != 0.) {
18107  HEpositivedirectionReconoiseDIF4->Fill(jphi, ccc1);
18108  ccctest = 1.; //HEpositivedirectionReconoiseDIF4->SetBinError(i,0.01);
18109  }
18110  } // for jphi
18111  if (ccctest > 0.) {
18112  //cout<<"777 kcountHEpositivedirectionReconoiseDIF4 = "<<kcountHEpositivedirectionReconoiseDIF4 <<" jeta-41= "<< jeta-41 <<endl;
18113  c3x5->cd(kcountHEpositivedirectionReconoiseDIF4);
18114  HEpositivedirectionReconoiseDIF4->SetMarkerStyle(20);
18115  HEpositivedirectionReconoiseDIF4->SetMarkerSize(0.4);
18116  HEpositivedirectionReconoiseDIF4->GetYaxis()->SetLabelSize(0.04);
18117  HEpositivedirectionReconoiseDIF4->SetXTitle("HEpositivedirectionReconoiseDIF4 \b");
18118  HEpositivedirectionReconoiseDIF4->SetMarkerColor(2);
18119  HEpositivedirectionReconoiseDIF4->SetLineColor(0);
18120  gPad->SetGridy();
18121  gPad->SetGridx();
18122  // gPad->SetLogy();
18123  if (kcountHEpositivedirectionReconoiseDIF4 == 1)
18124  HEpositivedirectionReconoiseDIF4->SetXTitle("DIF for HE+ jeta = 15; depth = 4 \b");
18125  if (kcountHEpositivedirectionReconoiseDIF4 == 2)
18126  HEpositivedirectionReconoiseDIF4->SetXTitle("DIF for HE+ jeta = 17; depth = 4 \b");
18127  if (kcountHEpositivedirectionReconoiseDIF4 == 3)
18128  HEpositivedirectionReconoiseDIF4->SetXTitle("DIF for HE+ jeta = 18; depth = 4 \b");
18129  if (kcountHEpositivedirectionReconoiseDIF4 == 4)
18130  HEpositivedirectionReconoiseDIF4->SetXTitle("DIF for HE+ jeta = 19; depth = 4 \b");
18131  if (kcountHEpositivedirectionReconoiseDIF4 == 5)
18132  HEpositivedirectionReconoiseDIF4->SetXTitle("DIF for HE+ jeta = 20; depth = 4 \b");
18133  if (kcountHEpositivedirectionReconoiseDIF4 == 6)
18134  HEpositivedirectionReconoiseDIF4->SetXTitle("DIF for HE+ jeta = 21; depth = 4 \b");
18135  if (kcountHEpositivedirectionReconoiseDIF4 == 7)
18136  HEpositivedirectionReconoiseDIF4->SetXTitle("DIF for HE+ jeta = 22; depth = 4 \b");
18137  if (kcountHEpositivedirectionReconoiseDIF4 == 8)
18138  HEpositivedirectionReconoiseDIF4->SetXTitle("DIF for HE+ jeta = 23; depth = 4 \b");
18139  if (kcountHEpositivedirectionReconoiseDIF4 == 9)
18140  HEpositivedirectionReconoiseDIF4->SetXTitle("DIF for HE+ jeta = 24; depth = 4 \b");
18141  if (kcountHEpositivedirectionReconoiseDIF4 == 10)
18142  HEpositivedirectionReconoiseDIF4->SetXTitle("DIF for HE+ jeta = 25; depth = 4 \b");
18143  if (kcountHEpositivedirectionReconoiseDIF4 == 11)
18144  HEpositivedirectionReconoiseDIF4->SetXTitle("DIF for HE+ jeta = 26; depth = 4 \b");
18145  if (kcountHEpositivedirectionReconoiseDIF4 == 12)
18146  HEpositivedirectionReconoiseDIF4->SetXTitle("DIF for HE+ jeta = 27; depth = 4 \b");
18147  HEpositivedirectionReconoiseDIF4->Draw("Error");
18148  kcountHEpositivedirectionReconoiseDIF4++;
18149  if (kcountHEpositivedirectionReconoiseDIF4 > 12)
18150  break; // 4x6 = 24
18151  } //ccctest>0
18152 
18153  } // for i
18154  } //if(jeta-41 >= -29 && jeta-41 <= -16)
18155  } //for jeta
18157  c3x5->Update();
18158  c3x5->Print("DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth4HE.png");
18159  c3x5->Clear();
18160  // clean-up
18161  if (h2CeffHEpositivedirectionReconoiseDIF4)
18162  delete h2CeffHEpositivedirectionReconoiseDIF4;
18163  //========================================================================================== 8
18164  //======================================================================
18165  //======================================================================1D plot: R vs phi , different eta, depth=5
18166  //cout<<" 1D plot: R vs phi , different eta, depth=5 *****" <<endl;
18167  c3x5->Clear();
18169  c3x5->Divide(3, 5);
18170  c3x5->cd(1);
18171  int kcountHEpositivedirectionReconoiseDIF5 = 1;
18172  TH1F *h2CeffHEpositivedirectionReconoiseDIF5 = new TH1F("h2CeffHEpositivedirectionReconoiseDIF5", "", nphi, 0., 72.);
18173 
18174  for (int jeta = 0; jeta < njeta; jeta++) {
18175  // positivedirectionReconoiseDIF:
18176  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
18177  // for (int i=0;i<ndepth;i++) {
18178  // depth=5
18179  for (int i = 4; i < 5; i++) {
18180  TH1F *HEpositivedirectionReconoiseDIF5 = (TH1F *)h2CeffHEpositivedirectionReconoiseDIF5->Clone("twod1");
18181 
18182  float ccctest = 0; // to avoid empty massive elements
18183  for (int jphi = 0; jphi < nphi; jphi++) {
18184  // cout<<"888 initial kcountHEpositivedirectionReconoiseDIF5 = "<<kcountHEpositivedirectionReconoiseDIF5 <<" jeta-41= "<< jeta-41 <<" jphi= "<< jphi <<" breconoisehe[i][jeta][jphi]= "<< breconoisehe[i][jeta][jphi] <<" depth= "<< i <<endl;
18185 
18186  double ccc1 = breconoisehe[i][jeta][jphi];
18187  if (ccc1 != 0.) {
18188  HEpositivedirectionReconoiseDIF5->Fill(jphi, ccc1);
18189  ccctest = 1.; //HEpositivedirectionReconoiseDIF5->SetBinError(i,0.01);
18190  }
18191  } // for jphi
18192  if (ccctest > 0.) {
18193  //cout<<"888 kcountHEpositivedirectionReconoiseDIF5 = "<<kcountHEpositivedirectionReconoiseDIF5 <<" jeta-41= "<< jeta-41 <<endl;
18194  c3x5->cd(kcountHEpositivedirectionReconoiseDIF5);
18195  HEpositivedirectionReconoiseDIF5->SetMarkerStyle(20);
18196  HEpositivedirectionReconoiseDIF5->SetMarkerSize(0.4);
18197  HEpositivedirectionReconoiseDIF5->GetYaxis()->SetLabelSize(0.04);
18198  HEpositivedirectionReconoiseDIF5->SetXTitle("HEpositivedirectionReconoiseDIF5 \b");
18199  HEpositivedirectionReconoiseDIF5->SetMarkerColor(2);
18200  HEpositivedirectionReconoiseDIF5->SetLineColor(0);
18201  gPad->SetGridy();
18202  gPad->SetGridx();
18203  // gPad->SetLogy();
18204  if (kcountHEpositivedirectionReconoiseDIF5 == 1)
18205  HEpositivedirectionReconoiseDIF5->SetXTitle("DIF for HE+ jeta = 17; depth = 5 \b");
18206  if (kcountHEpositivedirectionReconoiseDIF5 == 2)
18207  HEpositivedirectionReconoiseDIF5->SetXTitle("DIF for HE+ jeta = 18; depth = 5 \b");
18208  if (kcountHEpositivedirectionReconoiseDIF5 == 3)
18209  HEpositivedirectionReconoiseDIF5->SetXTitle("DIF for HE+ jeta = 19; depth = 5 \b");
18210  if (kcountHEpositivedirectionReconoiseDIF5 == 4)
18211  HEpositivedirectionReconoiseDIF5->SetXTitle("DIF for HE+ jeta = 20; depth = 5 \b");
18212  if (kcountHEpositivedirectionReconoiseDIF5 == 5)
18213  HEpositivedirectionReconoiseDIF5->SetXTitle("DIF for HE+ jeta = 21; depth = 5 \b");
18214  if (kcountHEpositivedirectionReconoiseDIF5 == 6)
18215  HEpositivedirectionReconoiseDIF5->SetXTitle("DIF for HE+ jeta = 22; depth = 5 \b");
18216  if (kcountHEpositivedirectionReconoiseDIF5 == 7)
18217  HEpositivedirectionReconoiseDIF5->SetXTitle("DIF for HE+ jeta = 23; depth = 5 \b");
18218  if (kcountHEpositivedirectionReconoiseDIF5 == 8)
18219  HEpositivedirectionReconoiseDIF5->SetXTitle("DIF for HE+ jeta = 24; depth = 5 \b");
18220  if (kcountHEpositivedirectionReconoiseDIF5 == 9)
18221  HEpositivedirectionReconoiseDIF5->SetXTitle("DIF for HE+ jeta = 25; depth = 5 \b");
18222  if (kcountHEpositivedirectionReconoiseDIF5 == 10)
18223  HEpositivedirectionReconoiseDIF5->SetXTitle("DIF for HE+ jeta = 26; depth = 5 \b");
18224  if (kcountHEpositivedirectionReconoiseDIF5 == 11)
18225  HEpositivedirectionReconoiseDIF5->SetXTitle("DIF for HE+ jeta = 27; depth = 5 \b");
18226  HEpositivedirectionReconoiseDIF5->Draw("Error");
18227  kcountHEpositivedirectionReconoiseDIF5++;
18228  if (kcountHEpositivedirectionReconoiseDIF5 > 11)
18229  break; // 4x6 = 24
18230  } //ccctest>0
18231 
18232  } // for i
18233  } //if(jeta-41 >= -29 && jeta-41 <= -16)
18234  } //for jeta
18236  c3x5->Update();
18237  c3x5->Print("DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth5HE.png");
18238  c3x5->Clear();
18239  // clean-up
18240  if (h2CeffHEpositivedirectionReconoiseDIF5)
18241  delete h2CeffHEpositivedirectionReconoiseDIF5;
18242  //========================================================================================== 9
18243  //======================================================================
18244  //======================================================================1D plot: R vs phi , different eta, depth=6
18245  //cout<<" 1D plot: R vs phi , different eta, depth=6 *****" <<endl;
18246  c3x5->Clear();
18248  c3x5->Divide(3, 5);
18249  c3x5->cd(1);
18250  int kcountHEpositivedirectionReconoiseDIF6 = 1;
18251  TH1F *h2CeffHEpositivedirectionReconoiseDIF6 = new TH1F("h2CeffHEpositivedirectionReconoiseDIF6", "", nphi, 0., 72.);
18252 
18253  for (int jeta = 0; jeta < njeta; jeta++) {
18254  // positivedirectionReconoiseDIF:
18255  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
18256  // for (int i=0;i<ndepth;i++) {
18257  // depth=6
18258  for (int i = 5; i < 6; i++) {
18259  TH1F *HEpositivedirectionReconoiseDIF6 = (TH1F *)h2CeffHEpositivedirectionReconoiseDIF6->Clone("twod1");
18260 
18261  float ccctest = 0; // to avoid empty massive elements
18262  for (int jphi = 0; jphi < nphi; jphi++) {
18263  double ccc1 = breconoisehe[i][jeta][jphi];
18264  if (ccc1 != 0.) {
18265  HEpositivedirectionReconoiseDIF6->Fill(jphi, ccc1);
18266  ccctest = 1.; //HEpositivedirectionReconoiseDIF6->SetBinError(i,0.01);
18267  }
18268  } // for jphi
18269  if (ccctest > 0.) {
18270  //cout<<"999 kcountHEpositivedirectionReconoiseDIF6 = "<<kcountHEpositivedirectionReconoiseDIF6 <<" jeta-41= "<< jeta-41 <<endl;
18271  c3x5->cd(kcountHEpositivedirectionReconoiseDIF6);
18272  HEpositivedirectionReconoiseDIF6->SetMarkerStyle(20);
18273  HEpositivedirectionReconoiseDIF6->SetMarkerSize(0.4);
18274  HEpositivedirectionReconoiseDIF6->GetYaxis()->SetLabelSize(0.04);
18275  HEpositivedirectionReconoiseDIF6->SetXTitle("HEpositivedirectionReconoiseDIF6 \b");
18276  HEpositivedirectionReconoiseDIF6->SetMarkerColor(2);
18277  HEpositivedirectionReconoiseDIF6->SetLineColor(0);
18278  gPad->SetGridy();
18279  gPad->SetGridx();
18280  // gPad->SetLogy();
18281  if (kcountHEpositivedirectionReconoiseDIF6 == 1)
18282  HEpositivedirectionReconoiseDIF6->SetXTitle("DIF for HE+ jeta = 18; depth = 6 \b");
18283  if (kcountHEpositivedirectionReconoiseDIF6 == 2)
18284  HEpositivedirectionReconoiseDIF6->SetXTitle("DIF for HE+ jeta = 19; depth = 6 \b");
18285  if (kcountHEpositivedirectionReconoiseDIF6 == 3)
18286  HEpositivedirectionReconoiseDIF6->SetXTitle("DIF for HE+ jeta = 20; depth = 6 \b");
18287  if (kcountHEpositivedirectionReconoiseDIF6 == 4)
18288  HEpositivedirectionReconoiseDIF6->SetXTitle("DIF for HE+ jeta = 21; depth = 6 \b");
18289  if (kcountHEpositivedirectionReconoiseDIF6 == 5)
18290  HEpositivedirectionReconoiseDIF6->SetXTitle("DIF for HE+ jeta = 22; depth = 6 \b");
18291  if (kcountHEpositivedirectionReconoiseDIF6 == 6)
18292  HEpositivedirectionReconoiseDIF6->SetXTitle("DIF for HE+ jeta = 23; depth = 6 \b");
18293  if (kcountHEpositivedirectionReconoiseDIF6 == 7)
18294  HEpositivedirectionReconoiseDIF6->SetXTitle("DIF for HE+ jeta = 24; depth = 6 \b");
18295  if (kcountHEpositivedirectionReconoiseDIF6 == 8)
18296  HEpositivedirectionReconoiseDIF6->SetXTitle("DIF for HE+ jeta = 25; depth = 6 \b");
18297  if (kcountHEpositivedirectionReconoiseDIF6 == 9)
18298  HEpositivedirectionReconoiseDIF6->SetXTitle("DIF for HE+ jeta = 26; depth = 6 \b");
18299  if (kcountHEpositivedirectionReconoiseDIF6 == 10)
18300  HEpositivedirectionReconoiseDIF6->SetXTitle("DIF for HE+ jeta = 27; depth = 6 \b");
18301  HEpositivedirectionReconoiseDIF6->Draw("Error");
18302  kcountHEpositivedirectionReconoiseDIF6++;
18303  if (kcountHEpositivedirectionReconoiseDIF6 > 10)
18304  break; // 4x6 = 24
18305  } //ccctest>0
18306 
18307  } // for i
18308  } //if(jeta-41 >= -29 && jeta-41 <= -16)
18309  } //for jeta
18311  c3x5->Update();
18312  c3x5->Print("DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth6HE.png");
18313  c3x5->Clear();
18314  // clean-up
18315  if (h2CeffHEpositivedirectionReconoiseDIF6)
18316  delete h2CeffHEpositivedirectionReconoiseDIF6;
18317  //========================================================================================== 10
18318  //======================================================================
18319  //======================================================================1D plot: R vs phi , different eta, depth=7
18320  //cout<<" 1D plot: R vs phi , different eta, depth=7 *****" <<endl;
18321  c3x5->Clear();
18323  c3x5->Divide(3, 5);
18324  c3x5->cd(1);
18325  int kcountHEpositivedirectionReconoiseDIF7 = 1;
18326  TH1F *h2CeffHEpositivedirectionReconoiseDIF7 = new TH1F("h2CeffHEpositivedirectionReconoiseDIF7", "", nphi, 0., 72.);
18327 
18328  for (int jeta = 0; jeta < njeta; jeta++) {
18329  // positivedirectionReconoiseDIF:
18330  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
18331  // for (int i=0;i<ndepth;i++) {
18332  // depth=7
18333  for (int i = 6; i < 7; i++) {
18334  TH1F *HEpositivedirectionReconoiseDIF7 = (TH1F *)h2CeffHEpositivedirectionReconoiseDIF7->Clone("twod1");
18335 
18336  float ccctest = 0; // to avoid empty massive elements
18337  for (int jphi = 0; jphi < nphi; jphi++) {
18338  double ccc1 = breconoisehe[i][jeta][jphi];
18339  if (ccc1 != 0.) {
18340  HEpositivedirectionReconoiseDIF7->Fill(jphi, ccc1);
18341  ccctest = 1.; //HEpositivedirectionReconoiseDIF7->SetBinError(i,0.01);
18342  }
18343  } // for jphi
18344  if (ccctest > 0.) {
18345  //cout<<"1010 kcountHEpositivedirectionReconoiseDIF7 = "<<kcountHEpositivedirectionReconoiseDIF7 <<" jeta-41= "<< jeta-41 <<endl;
18346  c3x5->cd(kcountHEpositivedirectionReconoiseDIF7);
18347  HEpositivedirectionReconoiseDIF7->SetMarkerStyle(20);
18348  HEpositivedirectionReconoiseDIF7->SetMarkerSize(0.4);
18349  HEpositivedirectionReconoiseDIF7->GetYaxis()->SetLabelSize(0.04);
18350  HEpositivedirectionReconoiseDIF7->SetXTitle("HEpositivedirectionReconoiseDIF7 \b");
18351  HEpositivedirectionReconoiseDIF7->SetMarkerColor(2);
18352  HEpositivedirectionReconoiseDIF7->SetLineColor(0);
18353  gPad->SetGridy();
18354  gPad->SetGridx();
18355  // gPad->SetLogy();
18356  if (kcountHEpositivedirectionReconoiseDIF7 == 1)
18357  HEpositivedirectionReconoiseDIF7->SetXTitle("DIF for HE+ jeta = 25; depth = 7 \b");
18358  if (kcountHEpositivedirectionReconoiseDIF7 == 2)
18359  HEpositivedirectionReconoiseDIF7->SetXTitle("DIF for HE+ jeta = 26; depth = 7 \b");
18360  if (kcountHEpositivedirectionReconoiseDIF7 == 3)
18361  HEpositivedirectionReconoiseDIF7->SetXTitle("DIF for HE+ jeta = 27; depth = 7 \b");
18362  HEpositivedirectionReconoiseDIF7->Draw("Error");
18363  kcountHEpositivedirectionReconoiseDIF7++;
18364  if (kcountHEpositivedirectionReconoiseDIF7 > 3)
18365  break; //
18366  } //ccctest>0
18367 
18368  } // for i
18369  } //if(jeta-41 >= -29 && jeta-41 <= -16)
18370  } //for jeta
18372  c3x5->Update();
18373  c3x5->Print("DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth7HE.png");
18374  c3x5->Clear();
18375  // clean-up
18376  if (h2CeffHEpositivedirectionReconoiseDIF7)
18377  delete h2CeffHEpositivedirectionReconoiseDIF7;
18378 
18380  //========================================================================================== 1114
18381  //======================================================================
18382  //======================================================================1D plot: R vs phi , different eta, depth=1
18383  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
18384  c3x5->Clear();
18386  c3x5->Divide(3, 5);
18387  c3x5->cd(1);
18388  int kcountHEnegativedirectionReconoiseDIF1 = 1;
18389  TH1F *h2CeffHEnegativedirectionReconoiseDIF1 = new TH1F("h2CeffHEnegativedirectionReconoiseDIF1", "", nphi, 0., 72.);
18390  for (int jeta = 0; jeta < njeta; jeta++) {
18391  // negativedirectionReconoiseDIF:
18392  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
18393  // for (int i=0;i<ndepth;i++) {
18394  // depth=1
18395  for (int i = 0; i < 1; i++) {
18396  TH1F *HEnegativedirectionReconoiseDIF1 = (TH1F *)h2CeffHEnegativedirectionReconoiseDIF1->Clone("twod1");
18397  float ccctest = 0; // to avoid empty massive elements
18398  for (int jphi = 0; jphi < nphi; jphi++) {
18399  double ccc1 = breconoisehe[i][jeta][jphi];
18400  if (ccc1 != 0.) {
18401  HEnegativedirectionReconoiseDIF1->Fill(jphi, ccc1);
18402  ccctest = 1.; //HEnegativedirectionReconoiseDIF1->SetBinError(i,0.01);
18403  }
18404  } // for jphi
18405  if (ccctest > 0.) {
18406  // cout<<"444 kcountHEnegativedirectionReconoiseDIF1 = "<<kcountHEnegativedirectionReconoiseDIF1 <<" jeta-41= "<< jeta-41 <<endl;
18407  c3x5->cd(kcountHEnegativedirectionReconoiseDIF1);
18408  HEnegativedirectionReconoiseDIF1->SetMarkerStyle(20);
18409  HEnegativedirectionReconoiseDIF1->SetMarkerSize(0.4);
18410  HEnegativedirectionReconoiseDIF1->GetYaxis()->SetLabelSize(0.04);
18411  HEnegativedirectionReconoiseDIF1->SetXTitle("HEnegativedirectionReconoiseDIF1 \b");
18412  HEnegativedirectionReconoiseDIF1->SetMarkerColor(2);
18413  HEnegativedirectionReconoiseDIF1->SetLineColor(0);
18414  gPad->SetGridy();
18415  gPad->SetGridx();
18416  // gPad->SetLogy();
18417  if (kcountHEnegativedirectionReconoiseDIF1 == 1)
18418  HEnegativedirectionReconoiseDIF1->SetXTitle("DIF for HE- jeta =-29; depth = 1 \b");
18419  if (kcountHEnegativedirectionReconoiseDIF1 == 2)
18420  HEnegativedirectionReconoiseDIF1->SetXTitle("DIF for HE- jeta =-28; depth = 1 \b");
18421  if (kcountHEnegativedirectionReconoiseDIF1 == 3)
18422  HEnegativedirectionReconoiseDIF1->SetXTitle("DIF for HE- jeta =-27; depth = 1 \b");
18423  if (kcountHEnegativedirectionReconoiseDIF1 == 4)
18424  HEnegativedirectionReconoiseDIF1->SetXTitle("DIF for HE- jeta =-26; depth = 1 \b");
18425  if (kcountHEnegativedirectionReconoiseDIF1 == 5)
18426  HEnegativedirectionReconoiseDIF1->SetXTitle("DIF for HE- jeta =-25; depth = 1 \b");
18427  if (kcountHEnegativedirectionReconoiseDIF1 == 6)
18428  HEnegativedirectionReconoiseDIF1->SetXTitle("DIF for HE- jeta =-24; depth = 1 \b");
18429  if (kcountHEnegativedirectionReconoiseDIF1 == 7)
18430  HEnegativedirectionReconoiseDIF1->SetXTitle("DIF for HE- jeta =-23; depth = 1 \b");
18431  if (kcountHEnegativedirectionReconoiseDIF1 == 8)
18432  HEnegativedirectionReconoiseDIF1->SetXTitle("DIF for HE- jeta =-22; depth = 1 \b");
18433  if (kcountHEnegativedirectionReconoiseDIF1 == 9)
18434  HEnegativedirectionReconoiseDIF1->SetXTitle("DIF for HE- jeta =-21; depth = 1 \b");
18435  if (kcountHEnegativedirectionReconoiseDIF1 == 10)
18436  HEnegativedirectionReconoiseDIF1->SetXTitle("DIF for HE- jeta =-20; depth = 1 \b");
18437  if (kcountHEnegativedirectionReconoiseDIF1 == 11)
18438  HEnegativedirectionReconoiseDIF1->SetXTitle("DIF for HE- jeta =-19; depth = 1 \b");
18439  if (kcountHEnegativedirectionReconoiseDIF1 == 12)
18440  HEnegativedirectionReconoiseDIF1->SetXTitle("DIF for HE- jeta =-18; depth = 1 \b");
18441  HEnegativedirectionReconoiseDIF1->Draw("Error");
18442  kcountHEnegativedirectionReconoiseDIF1++;
18443  if (kcountHEnegativedirectionReconoiseDIF1 > 12)
18444  break; // 4x6 = 24
18445  } //ccctest>0
18446 
18447  } // for i
18448  } //if(jeta-41 >= -29 && jeta-41 <= -16)
18449  } //for jeta
18451  c3x5->Update();
18452  c3x5->Print("DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth1HE.png");
18453  c3x5->Clear();
18454  // clean-up
18455  if (h2CeffHEnegativedirectionReconoiseDIF1)
18456  delete h2CeffHEnegativedirectionReconoiseDIF1;
18457 
18458  //========================================================================================== 1115
18459  //======================================================================
18460  //======================================================================1D plot: R vs phi , different eta, depth=2
18461  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
18462  c3x5->Clear();
18464  c3x5->Divide(3, 5);
18465  c3x5->cd(1);
18466  int kcountHEnegativedirectionReconoiseDIF2 = 1;
18467  TH1F *h2CeffHEnegativedirectionReconoiseDIF2 = new TH1F("h2CeffHEnegativedirectionReconoiseDIF2", "", nphi, 0., 72.);
18468  for (int jeta = 0; jeta < njeta; jeta++) {
18469  // negativedirectionReconoiseDIF:
18470  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
18471  // for (int i=0;i<ndepth;i++) {
18472  // depth=2
18473  for (int i = 1; i < 2; i++) {
18474  TH1F *HEnegativedirectionReconoiseDIF2 = (TH1F *)h2CeffHEnegativedirectionReconoiseDIF2->Clone("twod1");
18475  float ccctest = 0; // to avoid empty massive elements
18476  for (int jphi = 0; jphi < nphi; jphi++) {
18477  double ccc1 = breconoisehe[i][jeta][jphi];
18478  if (ccc1 != 0.) {
18479  HEnegativedirectionReconoiseDIF2->Fill(jphi, ccc1);
18480  ccctest = 1.; //HEnegativedirectionReconoiseDIF2->SetBinError(i,0.01);
18481  }
18482  } // for jphi
18483  if (ccctest > 0.) {
18484  //cout<<"555 kcountHEnegativedirectionReconoiseDIF2 = "<<kcountHEnegativedirectionReconoiseDIF2 <<" jeta-41= "<< jeta-41 <<endl;
18485  c3x5->cd(kcountHEnegativedirectionReconoiseDIF2);
18486  HEnegativedirectionReconoiseDIF2->SetMarkerStyle(20);
18487  HEnegativedirectionReconoiseDIF2->SetMarkerSize(0.4);
18488  HEnegativedirectionReconoiseDIF2->GetYaxis()->SetLabelSize(0.04);
18489  HEnegativedirectionReconoiseDIF2->SetXTitle("HEnegativedirectionReconoiseDIF2 \b");
18490  HEnegativedirectionReconoiseDIF2->SetMarkerColor(2);
18491  HEnegativedirectionReconoiseDIF2->SetLineColor(0);
18492  gPad->SetGridy();
18493  gPad->SetGridx();
18494  // gPad->SetLogy();
18495  if (kcountHEnegativedirectionReconoiseDIF2 == 1)
18496  HEnegativedirectionReconoiseDIF2->SetXTitle("DIF for HE- jeta =-29; depth = 2 \b");
18497  if (kcountHEnegativedirectionReconoiseDIF2 == 2)
18498  HEnegativedirectionReconoiseDIF2->SetXTitle("DIF for HE- jeta =-28; depth = 2 \b");
18499  if (kcountHEnegativedirectionReconoiseDIF2 == 3)
18500  HEnegativedirectionReconoiseDIF2->SetXTitle("DIF for HE- jeta =-27; depth = 2 \b");
18501  if (kcountHEnegativedirectionReconoiseDIF2 == 4)
18502  HEnegativedirectionReconoiseDIF2->SetXTitle("DIF for HE- jeta =-26; depth = 2 \b");
18503  if (kcountHEnegativedirectionReconoiseDIF2 == 5)
18504  HEnegativedirectionReconoiseDIF2->SetXTitle("DIF for HE- jeta =-25; depth = 2 \b");
18505  if (kcountHEnegativedirectionReconoiseDIF2 == 6)
18506  HEnegativedirectionReconoiseDIF2->SetXTitle("DIF for HE- jeta =-24; depth = 2 \b");
18507  if (kcountHEnegativedirectionReconoiseDIF2 == 7)
18508  HEnegativedirectionReconoiseDIF2->SetXTitle("DIF for HE- jeta =-23; depth = 2 \b");
18509  if (kcountHEnegativedirectionReconoiseDIF2 == 8)
18510  HEnegativedirectionReconoiseDIF2->SetXTitle("DIF for HE- jeta =-22; depth = 2 \b");
18511  if (kcountHEnegativedirectionReconoiseDIF2 == 9)
18512  HEnegativedirectionReconoiseDIF2->SetXTitle("DIF for HE- jeta =-21; depth = 2 \b");
18513  if (kcountHEnegativedirectionReconoiseDIF2 == 10)
18514  HEnegativedirectionReconoiseDIF2->SetXTitle("DIF for HE- jeta =-20; depth = 2 \b");
18515  if (kcountHEnegativedirectionReconoiseDIF2 == 11)
18516  HEnegativedirectionReconoiseDIF2->SetXTitle("DIF for HE- jeta =-19; depth = 2 \b");
18517  if (kcountHEnegativedirectionReconoiseDIF2 == 12)
18518  HEnegativedirectionReconoiseDIF2->SetXTitle("DIF for HE- jeta =-18; depth = 2 \b");
18519  if (kcountHEnegativedirectionReconoiseDIF2 == 13)
18520  HEnegativedirectionReconoiseDIF2->SetXTitle("DIF for HE- jeta =-17; depth = 2 \b");
18521  HEnegativedirectionReconoiseDIF2->Draw("Error");
18522  kcountHEnegativedirectionReconoiseDIF2++;
18523  if (kcountHEnegativedirectionReconoiseDIF2 > 13)
18524  break; // 4x6 = 24
18525  } //ccctest>0
18526 
18527  } // for i
18528  } //if(jeta-41 >= -29 && jeta-41 <= -16)
18529  } //for jeta
18531  c3x5->Update();
18532  c3x5->Print("DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth2HE.png");
18533  c3x5->Clear();
18534  // clean-up
18535  if (h2CeffHEnegativedirectionReconoiseDIF2)
18536  delete h2CeffHEnegativedirectionReconoiseDIF2;
18537  //========================================================================================== 1116
18538  //======================================================================
18539  //======================================================================1D plot: R vs phi , different eta, depth=3
18540  //cout<<" 1D plot: R vs phi , different eta, depth=3 *****" <<endl;
18541  c3x5->Clear();
18543  c3x5->Divide(3, 5);
18544  c3x5->cd(1);
18545  int kcountHEnegativedirectionReconoiseDIF3 = 1;
18546  TH1F *h2CeffHEnegativedirectionReconoiseDIF3 = new TH1F("h2CeffHEnegativedirectionReconoiseDIF3", "", nphi, 0., 72.);
18547  for (int jeta = 0; jeta < njeta; jeta++) {
18548  // negativedirectionReconoiseDIF:
18549  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
18550  // for (int i=0;i<ndepth;i++) {
18551  // depth=3
18552  for (int i = 2; i < 3; i++) {
18553  TH1F *HEnegativedirectionReconoiseDIF3 = (TH1F *)h2CeffHEnegativedirectionReconoiseDIF3->Clone("twod1");
18554  float ccctest = 0; // to avoid empty massive elements
18555  for (int jphi = 0; jphi < nphi; jphi++) {
18556  double ccc1 = breconoisehe[i][jeta][jphi];
18557  if (ccc1 != 0.) {
18558  HEnegativedirectionReconoiseDIF3->Fill(jphi, ccc1);
18559  ccctest = 1.; //HEnegativedirectionReconoiseDIF3->SetBinError(i,0.01);
18560  }
18561  } // for jphi
18562  if (ccctest > 0.) {
18563  //cout<<"666 kcountHEnegativedirectionReconoiseDIF3 = "<<kcountHEnegativedirectionReconoiseDIF3 <<" jeta-41= "<< jeta-41 <<endl;
18564  c3x5->cd(kcountHEnegativedirectionReconoiseDIF3);
18565  HEnegativedirectionReconoiseDIF3->SetMarkerStyle(20);
18566  HEnegativedirectionReconoiseDIF3->SetMarkerSize(0.4);
18567  HEnegativedirectionReconoiseDIF3->GetYaxis()->SetLabelSize(0.04);
18568  HEnegativedirectionReconoiseDIF3->SetXTitle("HEnegativedirectionReconoiseDIF3 \b");
18569  HEnegativedirectionReconoiseDIF3->SetMarkerColor(2);
18570  HEnegativedirectionReconoiseDIF3->SetLineColor(0);
18571  gPad->SetGridy();
18572  gPad->SetGridx();
18573  // gPad->SetLogy();
18574  if (kcountHEnegativedirectionReconoiseDIF3 == 1)
18575  HEnegativedirectionReconoiseDIF3->SetXTitle("DIF for HE- jeta =-29; depth = 3 \b");
18576  if (kcountHEnegativedirectionReconoiseDIF3 == 2)
18577  HEnegativedirectionReconoiseDIF3->SetXTitle("DIF for HE- jeta =-28; depth = 3 \b");
18578  if (kcountHEnegativedirectionReconoiseDIF3 == 3)
18579  HEnegativedirectionReconoiseDIF3->SetXTitle("DIF for HE- jeta =-27; depth = 3 \b");
18580  if (kcountHEnegativedirectionReconoiseDIF3 == 4)
18581  HEnegativedirectionReconoiseDIF3->SetXTitle("DIF for HE- jeta =-26; depth = 3 \b");
18582  if (kcountHEnegativedirectionReconoiseDIF3 == 5)
18583  HEnegativedirectionReconoiseDIF3->SetXTitle("DIF for HE- jeta =-25; depth = 3 \b");
18584  if (kcountHEnegativedirectionReconoiseDIF3 == 6)
18585  HEnegativedirectionReconoiseDIF3->SetXTitle("DIF for HE- jeta =-24; depth = 3 \b");
18586  if (kcountHEnegativedirectionReconoiseDIF3 == 7)
18587  HEnegativedirectionReconoiseDIF3->SetXTitle("DIF for HE- jeta =-23; depth = 3 \b");
18588  if (kcountHEnegativedirectionReconoiseDIF3 == 8)
18589  HEnegativedirectionReconoiseDIF3->SetXTitle("DIF for HE- jeta =-22; depth = 3 \b");
18590  if (kcountHEnegativedirectionReconoiseDIF3 == 9)
18591  HEnegativedirectionReconoiseDIF3->SetXTitle("DIF for HE- jeta =-21; depth = 3 \b");
18592  if (kcountHEnegativedirectionReconoiseDIF3 == 10)
18593  HEnegativedirectionReconoiseDIF3->SetXTitle("DIF for HE- jeta =-20; depth = 3 \b");
18594  if (kcountHEnegativedirectionReconoiseDIF3 == 11)
18595  HEnegativedirectionReconoiseDIF3->SetXTitle("DIF for HE- jeta =-19; depth = 3 \b");
18596  if (kcountHEnegativedirectionReconoiseDIF3 == 12)
18597  HEnegativedirectionReconoiseDIF3->SetXTitle("DIF for HE- jeta =-18; depth = 3 \b");
18598  if (kcountHEnegativedirectionReconoiseDIF3 == 13)
18599  HEnegativedirectionReconoiseDIF3->SetXTitle("DIF for HE- jeta =-17; depth = 3 \b");
18600  HEnegativedirectionReconoiseDIF3->Draw("Error");
18601  kcountHEnegativedirectionReconoiseDIF3++;
18602  if (kcountHEnegativedirectionReconoiseDIF3 > 13)
18603  break; // 4x6 = 24
18604  } //ccctest>0
18605 
18606  } // for i
18607  } //if(jeta-41 >= -29 && jeta-41 <= -16)
18608  } //for jeta
18610  c3x5->Update();
18611  c3x5->Print("DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth3HE.png");
18612  c3x5->Clear();
18613  // clean-up
18614  if (h2CeffHEnegativedirectionReconoiseDIF3)
18615  delete h2CeffHEnegativedirectionReconoiseDIF3;
18616  //========================================================================================== 1117
18617  //======================================================================
18618  //======================================================================1D plot: R vs phi , different eta, depth=4
18619  //cout<<" 1D plot: R vs phi , different eta, depth=4 *****" <<endl;
18620  c3x5->Clear();
18622  c3x5->Divide(3, 5);
18623  c3x5->cd(1);
18624  int kcountHEnegativedirectionReconoiseDIF4 = 1;
18625  TH1F *h2CeffHEnegativedirectionReconoiseDIF4 = new TH1F("h2CeffHEnegativedirectionReconoiseDIF4", "", nphi, 0., 72.);
18626 
18627  for (int jeta = 0; jeta < njeta; jeta++) {
18628  // negativedirectionReconoiseDIF:
18629  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
18630  // for (int i=0;i<ndepth;i++) {
18631  // depth=4
18632  for (int i = 3; i < 4; i++) {
18633  TH1F *HEnegativedirectionReconoiseDIF4 = (TH1F *)h2CeffHEnegativedirectionReconoiseDIF4->Clone("twod1");
18634 
18635  float ccctest = 0; // to avoid empty massive elements
18636  for (int jphi = 0; jphi < nphi; jphi++) {
18637  double ccc1 = breconoisehe[i][jeta][jphi];
18638  if (ccc1 != 0.) {
18639  HEnegativedirectionReconoiseDIF4->Fill(jphi, ccc1);
18640  ccctest = 1.; //HEnegativedirectionReconoiseDIF4->SetBinError(i,0.01);
18641  }
18642  } // for jphi
18643  if (ccctest > 0.) {
18644  //cout<<"777 kcountHEnegativedirectionReconoiseDIF4 = "<<kcountHEnegativedirectionReconoiseDIF4 <<" jeta-41= "<< jeta-41 <<endl;
18645  c3x5->cd(kcountHEnegativedirectionReconoiseDIF4);
18646  HEnegativedirectionReconoiseDIF4->SetMarkerStyle(20);
18647  HEnegativedirectionReconoiseDIF4->SetMarkerSize(0.4);
18648  HEnegativedirectionReconoiseDIF4->GetYaxis()->SetLabelSize(0.04);
18649  HEnegativedirectionReconoiseDIF4->SetXTitle("HEnegativedirectionReconoiseDIF4 \b");
18650  HEnegativedirectionReconoiseDIF4->SetMarkerColor(2);
18651  HEnegativedirectionReconoiseDIF4->SetLineColor(0);
18652  gPad->SetGridy();
18653  gPad->SetGridx();
18654  // gPad->SetLogy();
18655  if (kcountHEnegativedirectionReconoiseDIF4 == 1)
18656  HEnegativedirectionReconoiseDIF4->SetXTitle("DIF for HE- jeta =-28; depth = 4 \b");
18657  if (kcountHEnegativedirectionReconoiseDIF4 == 2)
18658  HEnegativedirectionReconoiseDIF4->SetXTitle("DIF for HE- jeta =-27; depth = 4 \b");
18659  if (kcountHEnegativedirectionReconoiseDIF4 == 3)
18660  HEnegativedirectionReconoiseDIF4->SetXTitle("DIF for HE- jeta =-26; depth = 4 \b");
18661  if (kcountHEnegativedirectionReconoiseDIF4 == 4)
18662  HEnegativedirectionReconoiseDIF4->SetXTitle("DIF for HE- jeta =-25; depth = 4 \b");
18663  if (kcountHEnegativedirectionReconoiseDIF4 == 5)
18664  HEnegativedirectionReconoiseDIF4->SetXTitle("DIF for HE- jeta =-24; depth = 4 \b");
18665  if (kcountHEnegativedirectionReconoiseDIF4 == 6)
18666  HEnegativedirectionReconoiseDIF4->SetXTitle("DIF for HE- jeta =-23; depth = 4 \b");
18667  if (kcountHEnegativedirectionReconoiseDIF4 == 7)
18668  HEnegativedirectionReconoiseDIF4->SetXTitle("DIF for HE- jeta =-22; depth = 4 \b");
18669  if (kcountHEnegativedirectionReconoiseDIF4 == 8)
18670  HEnegativedirectionReconoiseDIF4->SetXTitle("DIF for HE- jeta =-21; depth = 4 \b");
18671  if (kcountHEnegativedirectionReconoiseDIF4 == 9)
18672  HEnegativedirectionReconoiseDIF4->SetXTitle("DIF for HE- jeta =-20; depth = 4 \b");
18673  if (kcountHEnegativedirectionReconoiseDIF4 == 10)
18674  HEnegativedirectionReconoiseDIF4->SetXTitle("DIF for HE- jeta =-19; depth = 4 \b");
18675  if (kcountHEnegativedirectionReconoiseDIF4 == 11)
18676  HEnegativedirectionReconoiseDIF4->SetXTitle("DIF for HE- jeta =-18; depth = 4 \b");
18677  if (kcountHEnegativedirectionReconoiseDIF4 == 12)
18678  HEnegativedirectionReconoiseDIF4->SetXTitle("DIF for HE- jeta =-16; depth = 4 \b");
18679  HEnegativedirectionReconoiseDIF4->Draw("Error");
18680  kcountHEnegativedirectionReconoiseDIF4++;
18681  if (kcountHEnegativedirectionReconoiseDIF4 > 12)
18682  break; // 4x6 = 24
18683  } //ccctest>0
18684 
18685  } // for i
18686  } //if(jeta-41 >= -29 && jeta-41 <= -16)
18687  } //for jeta
18689  c3x5->Update();
18690  c3x5->Print("DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth4HE.png");
18691  c3x5->Clear();
18692  // clean-up
18693  if (h2CeffHEnegativedirectionReconoiseDIF4)
18694  delete h2CeffHEnegativedirectionReconoiseDIF4;
18695  //========================================================================================== 1118
18696  //======================================================================
18697  //======================================================================1D plot: R vs phi , different eta, depth=5
18698  //cout<<" 1D plot: R vs phi , different eta, depth=5 *****" <<endl;
18699  c3x5->Clear();
18701  c3x5->Divide(3, 5);
18702  c3x5->cd(1);
18703  int kcountHEnegativedirectionReconoiseDIF5 = 1;
18704  TH1F *h2CeffHEnegativedirectionReconoiseDIF5 = new TH1F("h2CeffHEnegativedirectionReconoiseDIF5", "", nphi, 0., 72.);
18705 
18706  for (int jeta = 0; jeta < njeta; jeta++) {
18707  // negativedirectionReconoiseDIF:
18708  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
18709  // for (int i=0;i<ndepth;i++) {
18710  // depth=5
18711  for (int i = 4; i < 5; i++) {
18712  TH1F *HEnegativedirectionReconoiseDIF5 = (TH1F *)h2CeffHEnegativedirectionReconoiseDIF5->Clone("twod1");
18713 
18714  float ccctest = 0; // to avoid empty massive elements
18715  for (int jphi = 0; jphi < nphi; jphi++) {
18716  // cout<<"888 initial kcountHEnegativedirectionReconoiseDIF5 = "<<kcountHEnegativedirectionReconoiseDIF5 <<" jeta-41= "<< jeta-41 <<" jphi= "<< jphi <<" breconoisehe[i][jeta][jphi]= "<< breconoisehe[i][jeta][jphi] <<" depth= "<< i <<endl;
18717 
18718  double ccc1 = breconoisehe[i][jeta][jphi];
18719  if (ccc1 != 0.) {
18720  HEnegativedirectionReconoiseDIF5->Fill(jphi, ccc1);
18721  ccctest = 1.; //HEnegativedirectionReconoiseDIF5->SetBinError(i,0.01);
18722  }
18723  } // for jphi
18724  if (ccctest > 0.) {
18725  //cout<<"888 kcountHEnegativedirectionReconoiseDIF5 = "<<kcountHEnegativedirectionReconoiseDIF5 <<" jeta-41= "<< jeta-41 <<endl;
18726  c3x5->cd(kcountHEnegativedirectionReconoiseDIF5);
18727  HEnegativedirectionReconoiseDIF5->SetMarkerStyle(20);
18728  HEnegativedirectionReconoiseDIF5->SetMarkerSize(0.4);
18729  HEnegativedirectionReconoiseDIF5->GetYaxis()->SetLabelSize(0.04);
18730  HEnegativedirectionReconoiseDIF5->SetXTitle("HEnegativedirectionReconoiseDIF5 \b");
18731  HEnegativedirectionReconoiseDIF5->SetMarkerColor(2);
18732  HEnegativedirectionReconoiseDIF5->SetLineColor(0);
18733  gPad->SetGridy();
18734  gPad->SetGridx();
18735  // gPad->SetLogy();
18736  if (kcountHEnegativedirectionReconoiseDIF5 == 1)
18737  HEnegativedirectionReconoiseDIF5->SetXTitle("DIF for HE- jeta =-28; depth = 5 \b");
18738  if (kcountHEnegativedirectionReconoiseDIF5 == 2)
18739  HEnegativedirectionReconoiseDIF5->SetXTitle("DIF for HE- jeta =-27; depth = 5 \b");
18740  if (kcountHEnegativedirectionReconoiseDIF5 == 3)
18741  HEnegativedirectionReconoiseDIF5->SetXTitle("DIF for HE- jeta =-26; depth = 5 \b");
18742  if (kcountHEnegativedirectionReconoiseDIF5 == 4)
18743  HEnegativedirectionReconoiseDIF5->SetXTitle("DIF for HE- jeta =-25; depth = 5 \b");
18744  if (kcountHEnegativedirectionReconoiseDIF5 == 5)
18745  HEnegativedirectionReconoiseDIF5->SetXTitle("DIF for HE- jeta =-24; depth = 5 \b");
18746  if (kcountHEnegativedirectionReconoiseDIF5 == 6)
18747  HEnegativedirectionReconoiseDIF5->SetXTitle("DIF for HE- jeta =-23; depth = 5 \b");
18748  if (kcountHEnegativedirectionReconoiseDIF5 == 7)
18749  HEnegativedirectionReconoiseDIF5->SetXTitle("DIF for HE- jeta =-22; depth = 5 \b");
18750  if (kcountHEnegativedirectionReconoiseDIF5 == 8)
18751  HEnegativedirectionReconoiseDIF5->SetXTitle("DIF for HE- jeta =-21; depth = 5 \b");
18752  if (kcountHEnegativedirectionReconoiseDIF5 == 9)
18753  HEnegativedirectionReconoiseDIF5->SetXTitle("DIF for HE- jeta =-20; depth = 5 \b");
18754  if (kcountHEnegativedirectionReconoiseDIF5 == 10)
18755  HEnegativedirectionReconoiseDIF5->SetXTitle("DIF for HE- jeta =-19; depth = 5 \b");
18756  if (kcountHEnegativedirectionReconoiseDIF5 == 11)
18757  HEnegativedirectionReconoiseDIF5->SetXTitle("DIF for HE- jeta =-18; depth = 5 \b");
18758  HEnegativedirectionReconoiseDIF5->Draw("Error");
18759  kcountHEnegativedirectionReconoiseDIF5++;
18760  if (kcountHEnegativedirectionReconoiseDIF5 > 11)
18761  break; // 4x6 = 24
18762  } //ccctest>0
18763 
18764  } // for i
18765  } //if(jeta-41 >= -29 && jeta-41 <= -16)
18766  } //for jeta
18768  c3x5->Update();
18769  c3x5->Print("DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth5HE.png");
18770  c3x5->Clear();
18771  // clean-up
18772  if (h2CeffHEnegativedirectionReconoiseDIF5)
18773  delete h2CeffHEnegativedirectionReconoiseDIF5;
18774  //========================================================================================== 1119
18775  //======================================================================
18776  //======================================================================1D plot: R vs phi , different eta, depth=6
18777  //cout<<" 1D plot: R vs phi , different eta, depth=6 *****" <<endl;
18778  c3x5->Clear();
18780  c3x5->Divide(3, 5);
18781  c3x5->cd(1);
18782  int kcountHEnegativedirectionReconoiseDIF6 = 1;
18783  TH1F *h2CeffHEnegativedirectionReconoiseDIF6 = new TH1F("h2CeffHEnegativedirectionReconoiseDIF6", "", nphi, 0., 72.);
18784 
18785  for (int jeta = 0; jeta < njeta; jeta++) {
18786  // negativedirectionReconoiseDIF:
18787  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
18788  // for (int i=0;i<ndepth;i++) {
18789  // depth=6
18790  for (int i = 5; i < 6; i++) {
18791  TH1F *HEnegativedirectionReconoiseDIF6 = (TH1F *)h2CeffHEnegativedirectionReconoiseDIF6->Clone("twod1");
18792 
18793  float ccctest = 0; // to avoid empty massive elements
18794  for (int jphi = 0; jphi < nphi; jphi++) {
18795  double ccc1 = breconoisehe[i][jeta][jphi];
18796  if (ccc1 != 0.) {
18797  HEnegativedirectionReconoiseDIF6->Fill(jphi, ccc1);
18798  ccctest = 1.; //HEnegativedirectionReconoiseDIF6->SetBinError(i,0.01);
18799  }
18800  } // for jphi
18801  if (ccctest > 0.) {
18802  //cout<<"999 kcountHEnegativedirectionReconoiseDIF6 = "<<kcountHEnegativedirectionReconoiseDIF6 <<" jeta-41= "<< jeta-41 <<endl;
18803  c3x5->cd(kcountHEnegativedirectionReconoiseDIF6);
18804  HEnegativedirectionReconoiseDIF6->SetMarkerStyle(20);
18805  HEnegativedirectionReconoiseDIF6->SetMarkerSize(0.4);
18806  HEnegativedirectionReconoiseDIF6->GetYaxis()->SetLabelSize(0.04);
18807  HEnegativedirectionReconoiseDIF6->SetXTitle("HEnegativedirectionReconoiseDIF6 \b");
18808  HEnegativedirectionReconoiseDIF6->SetMarkerColor(2);
18809  HEnegativedirectionReconoiseDIF6->SetLineColor(0);
18810  gPad->SetGridy();
18811  gPad->SetGridx();
18812  // gPad->SetLogy();
18813  if (kcountHEnegativedirectionReconoiseDIF6 == 1)
18814  HEnegativedirectionReconoiseDIF6->SetXTitle("DIF for HE- jeta =-28; depth = 6 \b");
18815  if (kcountHEnegativedirectionReconoiseDIF6 == 2)
18816  HEnegativedirectionReconoiseDIF6->SetXTitle("DIF for HE- jeta =-27; depth = 6 \b");
18817  if (kcountHEnegativedirectionReconoiseDIF6 == 3)
18818  HEnegativedirectionReconoiseDIF6->SetXTitle("DIF for HE- jeta =-26; depth = 6 \b");
18819  if (kcountHEnegativedirectionReconoiseDIF6 == 4)
18820  HEnegativedirectionReconoiseDIF6->SetXTitle("DIF for HE- jeta =-25; depth = 6 \b");
18821  if (kcountHEnegativedirectionReconoiseDIF6 == 5)
18822  HEnegativedirectionReconoiseDIF6->SetXTitle("DIF for HE- jeta =-24; depth = 6 \b");
18823  if (kcountHEnegativedirectionReconoiseDIF6 == 6)
18824  HEnegativedirectionReconoiseDIF6->SetXTitle("DIF for HE- jeta =-23; depth = 6 \b");
18825  if (kcountHEnegativedirectionReconoiseDIF6 == 7)
18826  HEnegativedirectionReconoiseDIF6->SetXTitle("DIF for HE- jeta =-22; depth = 6 \b");
18827  if (kcountHEnegativedirectionReconoiseDIF6 == 8)
18828  HEnegativedirectionReconoiseDIF6->SetXTitle("DIF for HE- jeta =-21; depth = 6 \b");
18829  if (kcountHEnegativedirectionReconoiseDIF6 == 9)
18830  HEnegativedirectionReconoiseDIF6->SetXTitle("DIF for HE- jeta =-20; depth = 6 \b");
18831  if (kcountHEnegativedirectionReconoiseDIF6 == 10)
18832  HEnegativedirectionReconoiseDIF6->SetXTitle("DIF for HE- jeta =-19; depth = 6 \b");
18833  HEnegativedirectionReconoiseDIF6->Draw("Error");
18834  kcountHEnegativedirectionReconoiseDIF6++;
18835  if (kcountHEnegativedirectionReconoiseDIF6 > 10)
18836  break; // 4x6 = 24
18837  } //ccctest>0
18838 
18839  } // for i
18840  } //if(jeta-41 >= -29 && jeta-41 <= -16)
18841  } //for jeta
18843  c3x5->Update();
18844  c3x5->Print("DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth6HE.png");
18845  c3x5->Clear();
18846  // clean-up
18847  if (h2CeffHEnegativedirectionReconoiseDIF6)
18848  delete h2CeffHEnegativedirectionReconoiseDIF6;
18849  //========================================================================================== 11110
18850  //======================================================================
18851  //======================================================================1D plot: R vs phi , different eta, depth=7
18852  //cout<<" 1D plot: R vs phi , different eta, depth=7 *****" <<endl;
18853  c3x5->Clear();
18855  c3x5->Divide(3, 5);
18856  c3x5->cd(1);
18857  int kcountHEnegativedirectionReconoiseDIF7 = 1;
18858  TH1F *h2CeffHEnegativedirectionReconoiseDIF7 = new TH1F("h2CeffHEnegativedirectionReconoiseDIF7", "", nphi, 0., 72.);
18859 
18860  for (int jeta = 0; jeta < njeta; jeta++) {
18861  // negativedirectionReconoiseDIF:
18862  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
18863  // for (int i=0;i<ndepth;i++) {
18864  // depth=7
18865  for (int i = 6; i < 7; i++) {
18866  TH1F *HEnegativedirectionReconoiseDIF7 = (TH1F *)h2CeffHEnegativedirectionReconoiseDIF7->Clone("twod1");
18867 
18868  float ccctest = 0; // to avoid empty massive elements
18869  for (int jphi = 0; jphi < nphi; jphi++) {
18870  double ccc1 = breconoisehe[i][jeta][jphi];
18871  if (ccc1 != 0.) {
18872  HEnegativedirectionReconoiseDIF7->Fill(jphi, ccc1);
18873  ccctest = 1.; //HEnegativedirectionReconoiseDIF7->SetBinError(i,0.01);
18874  }
18875  } // for jphi
18876  if (ccctest > 0.) {
18877  //cout<<"1010 kcountHEnegativedirectionReconoiseDIF7 = "<<kcountHEnegativedirectionReconoiseDIF7 <<" jeta-41= "<< jeta-41 <<endl;
18878  c3x5->cd(kcountHEnegativedirectionReconoiseDIF7);
18879  HEnegativedirectionReconoiseDIF7->SetMarkerStyle(20);
18880  HEnegativedirectionReconoiseDIF7->SetMarkerSize(0.4);
18881  HEnegativedirectionReconoiseDIF7->GetYaxis()->SetLabelSize(0.04);
18882  HEnegativedirectionReconoiseDIF7->SetXTitle("HEnegativedirectionReconoiseDIF7 \b");
18883  HEnegativedirectionReconoiseDIF7->SetMarkerColor(2);
18884  HEnegativedirectionReconoiseDIF7->SetLineColor(0);
18885  gPad->SetGridy();
18886  gPad->SetGridx();
18887  // gPad->SetLogy();
18888  if (kcountHEnegativedirectionReconoiseDIF7 == 1)
18889  HEnegativedirectionReconoiseDIF7->SetXTitle("DIF for HE- jeta =-28; depth = 7 \b");
18890  if (kcountHEnegativedirectionReconoiseDIF7 == 2)
18891  HEnegativedirectionReconoiseDIF7->SetXTitle("DIF for HE- jeta =-27; depth = 7 \b");
18892  if (kcountHEnegativedirectionReconoiseDIF7 == 3)
18893  HEnegativedirectionReconoiseDIF7->SetXTitle("DIF for HE- jeta =-26; depth = 7 \b");
18894  HEnegativedirectionReconoiseDIF7->Draw("Error");
18895  kcountHEnegativedirectionReconoiseDIF7++;
18896  if (kcountHEnegativedirectionReconoiseDIF7 > 3)
18897  break; // 4x6 = 24
18898  } //ccctest>0
18899 
18900  } // for i
18901  } //if(jeta-41 >= -29 && jeta-41 <= -16)
18902  } //for jeta
18904  c3x5->Update();
18905  c3x5->Print("DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth7HE.png");
18906  c3x5->Clear();
18907  // clean-up
18908  if (h2CeffHEnegativedirectionReconoiseDIF7)
18909  delete h2CeffHEnegativedirectionReconoiseDIF7;
18910 
18911  //======================================================================================================================
18912  //======================================================================================================================
18914  //======================================================================================================================
18915  //======================================================================================================================
18916  //======================================================================================================================
18917 
18918  // DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD:
18919 
18920  //cout<<" Start Vaiance: preparation *****" <<endl;
18921  TH2F *reconoiseVariance1HE1 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy2_HE1");
18922  TH2F *reconoiseVariance0HE1 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HE1");
18923  TH2F *reconoiseVarianceHE1 = (TH2F *)reconoiseVariance1HE1->Clone("reconoiseVarianceHE1");
18924  reconoiseVarianceHE1->Divide(reconoiseVariance1HE1, reconoiseVariance0HE1, 1, 1, "B");
18925  TH2F *reconoiseVariance1HE2 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy2_HE2");
18926  TH2F *reconoiseVariance0HE2 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HE2");
18927  TH2F *reconoiseVarianceHE2 = (TH2F *)reconoiseVariance1HE2->Clone("reconoiseVarianceHE2");
18928  reconoiseVarianceHE2->Divide(reconoiseVariance1HE2, reconoiseVariance0HE2, 1, 1, "B");
18929  TH2F *reconoiseVariance1HE3 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy2_HE3");
18930  TH2F *reconoiseVariance0HE3 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HE3");
18931  TH2F *reconoiseVarianceHE3 = (TH2F *)reconoiseVariance1HE3->Clone("reconoiseVarianceHE3");
18932  reconoiseVarianceHE3->Divide(reconoiseVariance1HE3, reconoiseVariance0HE3, 1, 1, "B");
18933  TH2F *reconoiseVariance1HE4 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy2_HE4");
18934  TH2F *reconoiseVariance0HE4 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HE4");
18935  TH2F *reconoiseVarianceHE4 = (TH2F *)reconoiseVariance1HE4->Clone("reconoiseVarianceHE4");
18936  reconoiseVarianceHE4->Divide(reconoiseVariance1HE4, reconoiseVariance0HE4, 1, 1, "B");
18937  TH2F *reconoiseVariance1HE5 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy2_HE5");
18938  TH2F *reconoiseVariance0HE5 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HE5");
18939  TH2F *reconoiseVarianceHE5 = (TH2F *)reconoiseVariance1HE5->Clone("reconoiseVarianceHE5");
18940  reconoiseVarianceHE5->Divide(reconoiseVariance1HE5, reconoiseVariance0HE5, 1, 1, "B");
18941  TH2F *reconoiseVariance1HE6 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy2_HE6");
18942  TH2F *reconoiseVariance0HE6 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HE6");
18943  TH2F *reconoiseVarianceHE6 = (TH2F *)reconoiseVariance1HE6->Clone("reconoiseVarianceHE6");
18944  reconoiseVarianceHE6->Divide(reconoiseVariance1HE6, reconoiseVariance0HE6, 1, 1, "B");
18945  TH2F *reconoiseVariance1HE7 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy2_HE7");
18946  TH2F *reconoiseVariance0HE7 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HE7");
18947  TH2F *reconoiseVarianceHE7 = (TH2F *)reconoiseVariance1HE7->Clone("reconoiseVarianceHE7");
18948  reconoiseVarianceHE7->Divide(reconoiseVariance1HE7, reconoiseVariance0HE7, 1, 1, "B");
18949  //cout<<" Vaiance: preparation DONE *****" <<endl;
18950  //====================================================================== put Vaiance=Dispersia = Sig**2=<R**2> - (<R>)**2 into massive reconoisevariancehe
18951  // = sum(R*R)/N - (sum(R)/N)**2
18952  for (int jeta = 0; jeta < njeta; jeta++) {
18953  if ((jeta - 41 >= -29 && jeta - 41 <= -16) || (jeta - 41 >= 15 && jeta - 41 <= 28)) {
18954  //preparation for PHI normalization:
18955  double sumreconoiseHE0 = 0;
18956  int nsumreconoiseHE0 = 0;
18957  double sumreconoiseHE1 = 0;
18958  int nsumreconoiseHE1 = 0;
18959  double sumreconoiseHE2 = 0;
18960  int nsumreconoiseHE2 = 0;
18961  double sumreconoiseHE3 = 0;
18962  int nsumreconoiseHE3 = 0;
18963  double sumreconoiseHE4 = 0;
18964  int nsumreconoiseHE4 = 0;
18965  double sumreconoiseHE5 = 0;
18966  int nsumreconoiseHE5 = 0;
18967  double sumreconoiseHE6 = 0;
18968  int nsumreconoiseHE6 = 0;
18969  for (int jphi = 0; jphi < njphi; jphi++) {
18970  reconoisevariancehe[0][jeta][jphi] = reconoiseVarianceHE1->GetBinContent(jeta + 1, jphi + 1);
18971  reconoisevariancehe[1][jeta][jphi] = reconoiseVarianceHE2->GetBinContent(jeta + 1, jphi + 1);
18972  reconoisevariancehe[2][jeta][jphi] = reconoiseVarianceHE3->GetBinContent(jeta + 1, jphi + 1);
18973  reconoisevariancehe[3][jeta][jphi] = reconoiseVarianceHE4->GetBinContent(jeta + 1, jphi + 1);
18974  reconoisevariancehe[4][jeta][jphi] = reconoiseVarianceHE5->GetBinContent(jeta + 1, jphi + 1);
18975  reconoisevariancehe[5][jeta][jphi] = reconoiseVarianceHE6->GetBinContent(jeta + 1, jphi + 1);
18976  reconoisevariancehe[6][jeta][jphi] = reconoiseVarianceHE7->GetBinContent(jeta + 1, jphi + 1);
18977  if (reconoisevariancehe[0][jeta][jphi] != 0.) {
18978  sumreconoiseHE0 += reconoisevariancehe[0][jeta][jphi];
18979  ++nsumreconoiseHE0;
18980  }
18981  if (reconoisevariancehe[1][jeta][jphi] != 0.) {
18982  sumreconoiseHE1 += reconoisevariancehe[1][jeta][jphi];
18983  ++nsumreconoiseHE1;
18984  }
18985  if (reconoisevariancehe[2][jeta][jphi] != 0.) {
18986  sumreconoiseHE2 += reconoisevariancehe[2][jeta][jphi];
18987  ++nsumreconoiseHE2;
18988  }
18989  if (reconoisevariancehe[3][jeta][jphi] != 0.) {
18990  sumreconoiseHE3 += reconoisevariancehe[3][jeta][jphi];
18991  ++nsumreconoiseHE3;
18992  }
18993  if (reconoisevariancehe[4][jeta][jphi] != 0.) {
18994  sumreconoiseHE4 += reconoisevariancehe[4][jeta][jphi];
18995  ++nsumreconoiseHE4;
18996  }
18997  if (reconoisevariancehe[5][jeta][jphi] != 0.) {
18998  sumreconoiseHE5 += reconoisevariancehe[5][jeta][jphi];
18999  ++nsumreconoiseHE5;
19000  }
19001  if (reconoisevariancehe[6][jeta][jphi] != 0.) {
19002  sumreconoiseHE6 += reconoisevariancehe[6][jeta][jphi];
19003  ++nsumreconoiseHE6;
19004  }
19005  } // phi
19006  // PHI normalization :
19007  for (int jphi = 0; jphi < njphi; jphi++) {
19008  if (sumreconoiseHE0 != 0.)
19009  reconoisevariancehe[0][jeta][jphi] /= (sumreconoiseHE0 / nsumreconoiseHE0);
19010  if (sumreconoiseHE1 != 0.)
19011  reconoisevariancehe[1][jeta][jphi] /= (sumreconoiseHE1 / nsumreconoiseHE1);
19012  if (sumreconoiseHE2 != 0.)
19013  reconoisevariancehe[2][jeta][jphi] /= (sumreconoiseHE2 / nsumreconoiseHE2);
19014  if (sumreconoiseHE3 != 0.)
19015  reconoisevariancehe[3][jeta][jphi] /= (sumreconoiseHE3 / nsumreconoiseHE3);
19016  if (sumreconoiseHE4 != 0.)
19017  reconoisevariancehe[4][jeta][jphi] /= (sumreconoiseHE4 / nsumreconoiseHE4);
19018  if (sumreconoiseHE5 != 0.)
19019  reconoisevariancehe[5][jeta][jphi] /= (sumreconoiseHE5 / nsumreconoiseHE5);
19020  if (sumreconoiseHE6 != 0.)
19021  reconoisevariancehe[6][jeta][jphi] /= (sumreconoiseHE6 / nsumreconoiseHE6);
19022  } // phi
19023  // reconoisevariancehe (D) = sum(R*R)/N - (sum(R)/N)**2
19024  for (int jphi = 0; jphi < njphi; jphi++) {
19025  // cout<<"12 12 12 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
19026  reconoisevariancehe[0][jeta][jphi] -= areconoisehe[0][jeta][jphi] * areconoisehe[0][jeta][jphi];
19027  reconoisevariancehe[0][jeta][jphi] = fabs(reconoisevariancehe[0][jeta][jphi]);
19028  reconoisevariancehe[1][jeta][jphi] -= areconoisehe[1][jeta][jphi] * areconoisehe[1][jeta][jphi];
19029  reconoisevariancehe[1][jeta][jphi] = fabs(reconoisevariancehe[1][jeta][jphi]);
19030  reconoisevariancehe[2][jeta][jphi] -= areconoisehe[2][jeta][jphi] * areconoisehe[2][jeta][jphi];
19031  reconoisevariancehe[2][jeta][jphi] = fabs(reconoisevariancehe[2][jeta][jphi]);
19032  reconoisevariancehe[3][jeta][jphi] -= areconoisehe[3][jeta][jphi] * areconoisehe[3][jeta][jphi];
19033  reconoisevariancehe[3][jeta][jphi] = fabs(reconoisevariancehe[3][jeta][jphi]);
19034  reconoisevariancehe[4][jeta][jphi] -= areconoisehe[4][jeta][jphi] * areconoisehe[4][jeta][jphi];
19035  reconoisevariancehe[4][jeta][jphi] = fabs(reconoisevariancehe[4][jeta][jphi]);
19036  reconoisevariancehe[5][jeta][jphi] -= areconoisehe[5][jeta][jphi] * areconoisehe[5][jeta][jphi];
19037  reconoisevariancehe[5][jeta][jphi] = fabs(reconoisevariancehe[5][jeta][jphi]);
19038  reconoisevariancehe[6][jeta][jphi] -= areconoisehe[6][jeta][jphi] * areconoisehe[6][jeta][jphi];
19039  reconoisevariancehe[6][jeta][jphi] = fabs(reconoisevariancehe[6][jeta][jphi]);
19040  }
19041  }
19042  }
19043  //cout<<" Vaiance: DONE*****" <<endl;
19044  //------------------------ 2D-eta/phi-plot: D, averaged over depthes
19045  //======================================================================
19046  //======================================================================
19047  //cout<<" R2D-eta/phi-plot: D, averaged over depthes *****" <<endl;
19048  c1x1->Clear();
19050  c1x0->Divide(1, 1);
19051  c1x0->cd(1);
19052  TH2F *DefzDreconoiseHE42D = new TH2F("DefzDreconoiseHE42D", "", neta, -41., 41., nphi, 0., 72.);
19053  TH2F *DefzDreconoiseHE42D0 = new TH2F("DefzDreconoiseHE42D0", "", neta, -41., 41., nphi, 0., 72.);
19054  TH2F *DefzDreconoiseHE42DF = (TH2F *)DefzDreconoiseHE42D0->Clone("DefzDreconoiseHE42DF");
19055  for (int i = 0; i < ndepth; i++) {
19056  for (int jeta = 0; jeta < neta; jeta++) {
19057  if ((jeta - 41 >= -29 && jeta - 41 <= -16) || (jeta - 41 >= 15 && jeta - 41 <= 28)) {
19058  for (int jphi = 0; jphi < nphi; jphi++) {
19059  double ccc1 = reconoisevariancehe[i][jeta][jphi];
19060  int k2plot = jeta - 41;
19061  int kkk = k2plot; //if(k2plot >0 kkk=k2plot+1; //-41 +41 !=0
19062  if (areconoisehe[i][jeta][jphi] > 0.) {
19063  DefzDreconoiseHE42D->Fill(kkk, jphi, ccc1);
19064  DefzDreconoiseHE42D0->Fill(kkk, jphi, 1.);
19065  }
19066  }
19067  }
19068  }
19069  }
19070  DefzDreconoiseHE42DF->Divide(DefzDreconoiseHE42D, DefzDreconoiseHE42D0, 1, 1, "B"); // average A
19071  // DefzDreconoiseHE1->Sumw2();
19072  gPad->SetGridy();
19073  gPad->SetGridx(); // gPad->SetLogz();
19074  DefzDreconoiseHE42DF->SetMarkerStyle(20);
19075  DefzDreconoiseHE42DF->SetMarkerSize(0.4);
19076  DefzDreconoiseHE42DF->GetZaxis()->SetLabelSize(0.08);
19077  DefzDreconoiseHE42DF->SetXTitle("<D>_depth #eta \b");
19078  DefzDreconoiseHE42DF->SetYTitle(" #phi \b");
19079  DefzDreconoiseHE42DF->SetZTitle("<D>_depth \b");
19080  DefzDreconoiseHE42DF->SetMarkerColor(2);
19081  DefzDreconoiseHE42DF->SetLineColor(
19082  0); // DefzDreconoiseHE42DF->SetMaximum(1.000); // DefzDreconoiseHE42DF->SetMinimum(1.0);
19083  DefzDreconoiseHE42DF->Draw("COLZ");
19085  c1x0->Update();
19086  c1x0->Print("DreconoiseGeneralD2PhiSymmetryHE.png");
19087  c1x0->Clear();
19088  // clean-up
19089  if (DefzDreconoiseHE42D)
19090  delete DefzDreconoiseHE42D;
19091  if (DefzDreconoiseHE42D0)
19092  delete DefzDreconoiseHE42D0;
19093  if (DefzDreconoiseHE42DF)
19094  delete DefzDreconoiseHE42DF;
19095  //====================================================================== 1D plot: D vs phi , averaged over depthes & eta
19096  //======================================================================
19097  //cout<<" 1D plot: D vs phi , averaged over depthes & eta *****" <<endl;
19098  c1x1->Clear();
19100  c1x1->Divide(1, 1);
19101  c1x1->cd(1);
19102  TH1F *DefzDreconoiseHE41D = new TH1F("DefzDreconoiseHE41D", "", nphi, 0., 72.);
19103  TH1F *DefzDreconoiseHE41D0 = new TH1F("DefzDreconoiseHE41D0", "", nphi, 0., 72.);
19104  TH1F *DefzDreconoiseHE41DF = (TH1F *)DefzDreconoiseHE41D0->Clone("DefzDreconoiseHE41DF");
19105 
19106  for (int jphi = 0; jphi < nphi; jphi++) {
19107  for (int jeta = 0; jeta < neta; jeta++) {
19108  if ((jeta - 41 >= -29 && jeta - 41 <= -16) || (jeta - 41 >= 15 && jeta - 41 <= 28)) {
19109  for (int i = 0; i < ndepth; i++) {
19110  double ccc1 = reconoisevariancehe[i][jeta][jphi];
19111  if (areconoisehe[i][jeta][jphi] > 0.) {
19112  DefzDreconoiseHE41D->Fill(jphi, ccc1);
19113  DefzDreconoiseHE41D0->Fill(jphi, 1.);
19114  }
19115  }
19116  }
19117  }
19118  }
19119  // DefzDreconoiseHE41D->Sumw2();DefzDreconoiseHE41D0->Sumw2();
19120 
19121  DefzDreconoiseHE41DF->Divide(DefzDreconoiseHE41D, DefzDreconoiseHE41D0, 1, 1, "B"); // R averaged over depthes & eta
19122  DefzDreconoiseHE41D0->Sumw2();
19123  // for (int jphi=1;jphi<73;jphi++) {DefzDreconoiseHE41DF->SetBinError(jphi,0.01);}
19124  gPad->SetGridy();
19125  gPad->SetGridx(); // gPad->SetLogz();
19126  DefzDreconoiseHE41DF->SetMarkerStyle(20);
19127  DefzDreconoiseHE41DF->SetMarkerSize(1.4);
19128  DefzDreconoiseHE41DF->GetZaxis()->SetLabelSize(0.08);
19129  DefzDreconoiseHE41DF->SetXTitle("#phi \b");
19130  DefzDreconoiseHE41DF->SetYTitle(" <D> \b");
19131  DefzDreconoiseHE41DF->SetZTitle("<D>_PHI - AllDepthes \b");
19132  DefzDreconoiseHE41DF->SetMarkerColor(4);
19133  DefzDreconoiseHE41DF->SetLineColor(
19134  4); // DefzDreconoiseHE41DF->SetMinimum(0.8); DefzDreconoiseHE41DF->SetMinimum(-0.015);
19135  DefzDreconoiseHE41DF->Draw("Error");
19137  c1x1->Update();
19138  c1x1->Print("DreconoiseGeneralD1PhiSymmetryHE.png");
19139  c1x1->Clear();
19140  // clean-up
19141  if (DefzDreconoiseHE41D)
19142  delete DefzDreconoiseHE41D;
19143  if (DefzDreconoiseHE41D0)
19144  delete DefzDreconoiseHE41D0;
19145  if (DefzDreconoiseHE41DF)
19146  delete DefzDreconoiseHE41DF;
19147  //========================================================================================== 14
19148  //======================================================================
19149  //======================================================================1D plot: D vs phi , different eta, depth=1
19150  //cout<<" 1D plot: D vs phi , different eta, depth=1 *****" <<endl;
19151  c3x5->Clear();
19153  c3x5->Divide(3, 5);
19154  c3x5->cd(1);
19155  int kcountHEpositivedirectionReconoiseD1 = 1;
19156  TH1F *h2CeffHEpositivedirectionReconoiseD1 = new TH1F("h2CeffHEpositivedirectionReconoiseD1", "", nphi, 0., 72.);
19157 
19158  for (int jeta = 0; jeta < njeta; jeta++) {
19159  // positivedirectionReconoiseD:
19160  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
19161  // for (int i=0;i<ndepth;i++) {
19162  // depth=1
19163  for (int i = 0; i < 1; i++) {
19164  TH1F *HEpositivedirectionReconoiseD1 = (TH1F *)h2CeffHEpositivedirectionReconoiseD1->Clone("twod1");
19165 
19166  float ccctest = 0; // to avoid empty massive elements
19167  for (int jphi = 0; jphi < nphi; jphi++) {
19168  double ccc1 = reconoisevariancehe[i][jeta][jphi];
19169  if (areconoisehe[i][jeta][jphi] > 0.) {
19170  HEpositivedirectionReconoiseD1->Fill(jphi, ccc1);
19171  ccctest = 1.; //HEpositivedirectionReconoiseD1->SetBinError(i,0.01);
19172  }
19173  } // for jphi
19174  if (ccctest > 0.) {
19175  //cout<<"1414 kcountHEpositivedirectionReconoiseD1 = "<<kcountHEpositivedirectionReconoiseD1 <<" jeta-41= "<< jeta-41 <<endl;
19176  c3x5->cd(kcountHEpositivedirectionReconoiseD1);
19177  HEpositivedirectionReconoiseD1->SetMarkerStyle(20);
19178  HEpositivedirectionReconoiseD1->SetMarkerSize(0.4);
19179  HEpositivedirectionReconoiseD1->GetYaxis()->SetLabelSize(0.04);
19180  HEpositivedirectionReconoiseD1->SetXTitle("HEpositivedirectionReconoiseD1 \b");
19181  HEpositivedirectionReconoiseD1->SetMarkerColor(2);
19182  HEpositivedirectionReconoiseD1->SetLineColor(0);
19183  gPad->SetGridy();
19184  gPad->SetGridx();
19185  // gPad->SetLogy();
19186  if (kcountHEpositivedirectionReconoiseD1 == 1)
19187  HEpositivedirectionReconoiseD1->SetXTitle("D for HE+ jeta = 17; depth = 1 \b");
19188  if (kcountHEpositivedirectionReconoiseD1 == 2)
19189  HEpositivedirectionReconoiseD1->SetXTitle("D for HE+ jeta = 18; depth = 1 \b");
19190  if (kcountHEpositivedirectionReconoiseD1 == 3)
19191  HEpositivedirectionReconoiseD1->SetXTitle("D for HE+ jeta = 19; depth = 1 \b");
19192  if (kcountHEpositivedirectionReconoiseD1 == 4)
19193  HEpositivedirectionReconoiseD1->SetXTitle("D for HE+ jeta = 20; depth = 1 \b");
19194  if (kcountHEpositivedirectionReconoiseD1 == 5)
19195  HEpositivedirectionReconoiseD1->SetXTitle("D for HE+ jeta = 21; depth = 1 \b");
19196  if (kcountHEpositivedirectionReconoiseD1 == 6)
19197  HEpositivedirectionReconoiseD1->SetXTitle("D for HE+ jeta = 22; depth = 1 \b");
19198  if (kcountHEpositivedirectionReconoiseD1 == 7)
19199  HEpositivedirectionReconoiseD1->SetXTitle("D for HE+ jeta = 23; depth = 1 \b");
19200  if (kcountHEpositivedirectionReconoiseD1 == 8)
19201  HEpositivedirectionReconoiseD1->SetXTitle("D for HE+ jeta = 24; depth = 1 \b");
19202  if (kcountHEpositivedirectionReconoiseD1 == 9)
19203  HEpositivedirectionReconoiseD1->SetXTitle("D for HE+ jeta = 25; depth = 1 \b");
19204  if (kcountHEpositivedirectionReconoiseD1 == 10)
19205  HEpositivedirectionReconoiseD1->SetXTitle("D for HE+ jeta = 26; depth = 1 \b");
19206  if (kcountHEpositivedirectionReconoiseD1 == 11)
19207  HEpositivedirectionReconoiseD1->SetXTitle("D for HE+ jeta = 27; depth = 1 \b");
19208  if (kcountHEpositivedirectionReconoiseD1 == 12)
19209  HEpositivedirectionReconoiseD1->SetXTitle("D for HE+ jeta = 28; depth = 1 \b");
19210  HEpositivedirectionReconoiseD1->Draw("Error");
19211  kcountHEpositivedirectionReconoiseD1++;
19212  if (kcountHEpositivedirectionReconoiseD1 > 12)
19213  break; // 4x6 = 24
19214  } //ccctest>0
19215 
19216  } // for i
19217  } //if(jeta-41 >= 0)
19218  } //for jeta
19220  c3x5->Update();
19221  c3x5->Print("DreconoisePositiveDirectionhistD1PhiSymmetryDepth1HE.png");
19222  c3x5->Clear();
19223  // clean-up
19224  if (h2CeffHEpositivedirectionReconoiseD1)
19225  delete h2CeffHEpositivedirectionReconoiseD1;
19226  //========================================================================================== 15
19227  //======================================================================
19228  //======================================================================1D plot: D vs phi , different eta, depth=2
19229  //cout<<" 1D plot: D vs phi , different eta, depth=2 *****" <<endl;
19230  c3x5->Clear();
19231  c3x5->Divide(3, 5);
19232  c3x5->cd(1);
19233  int kcountHEpositivedirectionReconoiseD2 = 1;
19234  TH1F *h2CeffHEpositivedirectionReconoiseD2 = new TH1F("h2CeffHEpositivedirectionReconoiseD2", "", nphi, 0., 72.);
19235 
19236  for (int jeta = 0; jeta < njeta; jeta++) {
19237  // positivedirectionReconoiseD:
19238  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
19239  // for (int i=0;i<ndepth;i++) {
19240  // depth=2
19241  for (int i = 1; i < 2; i++) {
19242  TH1F *HEpositivedirectionReconoiseD2 = (TH1F *)h2CeffHEpositivedirectionReconoiseD2->Clone("twod1");
19243 
19244  float ccctest = 0; // to avoid empty massive elements
19245  for (int jphi = 0; jphi < nphi; jphi++) {
19246  double ccc1 = reconoisevariancehe[i][jeta][jphi];
19247  if (areconoisehe[i][jeta][jphi] > 0.) {
19248  HEpositivedirectionReconoiseD2->Fill(jphi, ccc1);
19249  ccctest = 1.; //HEpositivedirectionReconoiseD2->SetBinError(i,0.01);
19250  }
19251  } // for jphi
19252  if (ccctest > 0.) {
19253  //cout<<"1515 kcountHEpositivedirectionReconoiseD2 = "<<kcountHEpositivedirectionReconoiseD2 <<" jeta-41= "<< jeta-41 <<endl;
19254  c3x5->cd(kcountHEpositivedirectionReconoiseD2);
19255  HEpositivedirectionReconoiseD2->SetMarkerStyle(20);
19256  HEpositivedirectionReconoiseD2->SetMarkerSize(0.4);
19257  HEpositivedirectionReconoiseD2->GetYaxis()->SetLabelSize(0.04);
19258  HEpositivedirectionReconoiseD2->SetXTitle("HEpositivedirectionReconoiseD2 \b");
19259  HEpositivedirectionReconoiseD2->SetMarkerColor(2);
19260  HEpositivedirectionReconoiseD2->SetLineColor(0);
19261  gPad->SetGridy();
19262  gPad->SetGridx();
19263  // gPad->SetLogy();
19264  if (kcountHEpositivedirectionReconoiseD2 == 1)
19265  HEpositivedirectionReconoiseD2->SetXTitle("D for HE+ jeta = 16; depth = 2 \b");
19266  if (kcountHEpositivedirectionReconoiseD2 == 2)
19267  HEpositivedirectionReconoiseD2->SetXTitle("D for HE+ jeta = 17; depth = 2 \b");
19268  if (kcountHEpositivedirectionReconoiseD2 == 3)
19269  HEpositivedirectionReconoiseD2->SetXTitle("D for HE+ jeta = 18; depth = 2 \b");
19270  if (kcountHEpositivedirectionReconoiseD2 == 4)
19271  HEpositivedirectionReconoiseD2->SetXTitle("D for HE+ jeta = 19; depth = 2 \b");
19272  if (kcountHEpositivedirectionReconoiseD2 == 5)
19273  HEpositivedirectionReconoiseD2->SetXTitle("D for HE+ jeta = 20; depth = 2 \b");
19274  if (kcountHEpositivedirectionReconoiseD2 == 6)
19275  HEpositivedirectionReconoiseD2->SetXTitle("D for HE+ jeta = 21; depth = 2 \b");
19276  if (kcountHEpositivedirectionReconoiseD2 == 7)
19277  HEpositivedirectionReconoiseD2->SetXTitle("D for HE+ jeta = 22; depth = 2 \b");
19278  if (kcountHEpositivedirectionReconoiseD2 == 8)
19279  HEpositivedirectionReconoiseD2->SetXTitle("D for HE+ jeta = 23; depth = 2 \b");
19280  if (kcountHEpositivedirectionReconoiseD2 == 9)
19281  HEpositivedirectionReconoiseD2->SetXTitle("D for HE+ jeta = 24; depth = 2 \b");
19282  if (kcountHEpositivedirectionReconoiseD2 == 10)
19283  HEpositivedirectionReconoiseD2->SetXTitle("D for HE+ jeta = 25; depth = 2 \b");
19284  if (kcountHEpositivedirectionReconoiseD2 == 11)
19285  HEpositivedirectionReconoiseD2->SetXTitle("D for HE+ jeta = 26; depth = 2 \b");
19286  if (kcountHEpositivedirectionReconoiseD2 == 12)
19287  HEpositivedirectionReconoiseD2->SetXTitle("D for HE+ jeta = 27; depth = 2 \b");
19288  if (kcountHEpositivedirectionReconoiseD2 == 13)
19289  HEpositivedirectionReconoiseD2->SetXTitle("D for HE+ jeta = 28; depth = 2 \b");
19290  HEpositivedirectionReconoiseD2->Draw("Error");
19291  kcountHEpositivedirectionReconoiseD2++;
19292  if (kcountHEpositivedirectionReconoiseD2 > 13)
19293  break; // 4x6 = 24
19294  } //ccctest>0
19295 
19296  } // for i
19297  } //if(jeta-41 >= 0)
19298  } //for jeta
19300  c3x5->Update();
19301  c3x5->Print("DreconoisePositiveDirectionhistD1PhiSymmetryDepth2HE.png");
19302  c3x5->Clear();
19303  // clean-up
19304  if (h2CeffHEpositivedirectionReconoiseD2)
19305  delete h2CeffHEpositivedirectionReconoiseD2;
19306  //========================================================================================== 16
19307  //======================================================================
19308  //======================================================================1D plot: D vs phi , different eta, depth=3
19309  //cout<<" 1D plot: D vs phi , different eta, depth=3 *****" <<endl;
19310  c3x5->Clear();
19311  c3x5->Divide(3, 5);
19312  c3x5->cd(1);
19313  int kcountHEpositivedirectionReconoiseD3 = 1;
19314  TH1F *h2CeffHEpositivedirectionReconoiseD3 = new TH1F("h2CeffHEpositivedirectionReconoiseD3", "", nphi, 0., 72.);
19315 
19316  for (int jeta = 0; jeta < njeta; jeta++) {
19317  // positivedirectionReconoiseD:
19318  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
19319  // for (int i=0;i<ndepth;i++) {
19320  // depth=3
19321  for (int i = 2; i < 3; i++) {
19322  TH1F *HEpositivedirectionReconoiseD3 = (TH1F *)h2CeffHEpositivedirectionReconoiseD3->Clone("twod1");
19323 
19324  float ccctest = 0; // to avoid empty massive elements
19325  for (int jphi = 0; jphi < nphi; jphi++) {
19326  double ccc1 = reconoisevariancehe[i][jeta][jphi];
19327  if (areconoisehe[i][jeta][jphi] > 0.) {
19328  HEpositivedirectionReconoiseD3->Fill(jphi, ccc1);
19329  ccctest = 1.; //HEpositivedirectionReconoiseD3->SetBinError(i,0.01);
19330  }
19331  } // for jphi
19332  if (ccctest > 0.) {
19333  //cout<<"1616 kcountHEpositivedirectionReconoiseD3 = "<<kcountHEpositivedirectionReconoiseD3 <<" jeta-41= "<< jeta-41 <<endl;
19334  c3x5->cd(kcountHEpositivedirectionReconoiseD3);
19335  HEpositivedirectionReconoiseD3->SetMarkerStyle(20);
19336  HEpositivedirectionReconoiseD3->SetMarkerSize(0.4);
19337  HEpositivedirectionReconoiseD3->GetYaxis()->SetLabelSize(0.04);
19338  HEpositivedirectionReconoiseD3->SetXTitle("HEpositivedirectionReconoiseD3 \b");
19339  HEpositivedirectionReconoiseD3->SetMarkerColor(2);
19340  HEpositivedirectionReconoiseD3->SetLineColor(0);
19341  gPad->SetGridy();
19342  gPad->SetGridx();
19343  // gPad->SetLogy();
19344  if (kcountHEpositivedirectionReconoiseD3 == 1)
19345  HEpositivedirectionReconoiseD3->SetXTitle("D for HE+ jeta = 16; depth = 3 \b");
19346  if (kcountHEpositivedirectionReconoiseD3 == 2)
19347  HEpositivedirectionReconoiseD3->SetXTitle("D for HE+ jeta = 17; depth = 3 \b");
19348  if (kcountHEpositivedirectionReconoiseD3 == 3)
19349  HEpositivedirectionReconoiseD3->SetXTitle("D for HE+ jeta = 18; depth = 3 \b");
19350  if (kcountHEpositivedirectionReconoiseD3 == 4)
19351  HEpositivedirectionReconoiseD3->SetXTitle("D for HE+ jeta = 19; depth = 3 \b");
19352  if (kcountHEpositivedirectionReconoiseD3 == 5)
19353  HEpositivedirectionReconoiseD3->SetXTitle("D for HE+ jeta = 20; depth = 3 \b");
19354  if (kcountHEpositivedirectionReconoiseD3 == 6)
19355  HEpositivedirectionReconoiseD3->SetXTitle("D for HE+ jeta = 21; depth = 3 \b");
19356  if (kcountHEpositivedirectionReconoiseD3 == 7)
19357  HEpositivedirectionReconoiseD3->SetXTitle("D for HE+ jeta = 22; depth = 3 \b");
19358  if (kcountHEpositivedirectionReconoiseD3 == 8)
19359  HEpositivedirectionReconoiseD3->SetXTitle("D for HE+ jeta = 23; depth = 3 \b");
19360  if (kcountHEpositivedirectionReconoiseD3 == 9)
19361  HEpositivedirectionReconoiseD3->SetXTitle("D for HE+ jeta = 24; depth = 3 \b");
19362  if (kcountHEpositivedirectionReconoiseD3 == 10)
19363  HEpositivedirectionReconoiseD3->SetXTitle("D for HE+ jeta = 25; depth = 3 \b");
19364  if (kcountHEpositivedirectionReconoiseD3 == 11)
19365  HEpositivedirectionReconoiseD3->SetXTitle("D for HE+ jeta = 26; depth = 3 \b");
19366  if (kcountHEpositivedirectionReconoiseD3 == 12)
19367  HEpositivedirectionReconoiseD3->SetXTitle("D for HE+ jeta = 27; depth = 3 \b");
19368  if (kcountHEpositivedirectionReconoiseD3 == 13)
19369  HEpositivedirectionReconoiseD3->SetXTitle("D for HE+ jeta = 28; depth = 3 \b");
19370  HEpositivedirectionReconoiseD3->Draw("Error");
19371  kcountHEpositivedirectionReconoiseD3++;
19372  if (kcountHEpositivedirectionReconoiseD3 > 13)
19373  break; // 4x6 = 24
19374  } //ccctest>0
19375 
19376  } // for i
19377  } //if(jeta-41 >= 0)
19378  } //for jeta
19380  c3x5->Update();
19381  c3x5->Print("DreconoisePositiveDirectionhistD1PhiSymmetryDepth3HE.png");
19382  c3x5->Clear();
19383  // clean-up
19384  if (h2CeffHEpositivedirectionReconoiseD3)
19385  delete h2CeffHEpositivedirectionReconoiseD3;
19386  //========================================================================================== 17
19387  //======================================================================
19388  //======================================================================1D plot: D vs phi , different eta, depth=4
19389  //cout<<" 1D plot: D vs phi , different eta, depth=4 *****" <<endl;
19390  c3x5->Clear();
19391  c3x5->Divide(3, 5);
19392  c3x5->cd(1);
19393  int kcountHEpositivedirectionReconoiseD4 = 1;
19394  TH1F *h2CeffHEpositivedirectionReconoiseD4 = new TH1F("h2CeffHEpositivedirectionReconoiseD4", "", nphi, 0., 72.);
19395 
19396  for (int jeta = 0; jeta < njeta; jeta++) {
19397  // positivedirectionReconoiseD:
19398  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
19399  // for (int i=0;i<ndepth;i++) {
19400  // depth=4
19401  for (int i = 3; i < 4; i++) {
19402  TH1F *HEpositivedirectionReconoiseD4 = (TH1F *)h2CeffHEpositivedirectionReconoiseD4->Clone("twod1");
19403 
19404  float ccctest = 0; // to avoid empty massive elements
19405  for (int jphi = 0; jphi < nphi; jphi++) {
19406  double ccc1 = reconoisevariancehe[i][jeta][jphi];
19407  if (areconoisehe[i][jeta][jphi] > 0.) {
19408  HEpositivedirectionReconoiseD4->Fill(jphi, ccc1);
19409  ccctest = 1.; //HEpositivedirectionReconoiseD4->SetBinError(i,0.01);
19410  }
19411  } // for jphi
19412  if (ccctest > 0.) {
19413  //cout<<"1717 kcountHEpositivedirectionReconoiseD4 = "<<kcountHEpositivedirectionReconoiseD4 <<" jeta-41= "<< jeta-41 <<endl;
19414  c3x5->cd(kcountHEpositivedirectionReconoiseD4);
19415  HEpositivedirectionReconoiseD4->SetMarkerStyle(20);
19416  HEpositivedirectionReconoiseD4->SetMarkerSize(0.4);
19417  HEpositivedirectionReconoiseD4->GetYaxis()->SetLabelSize(0.04);
19418  HEpositivedirectionReconoiseD4->SetXTitle("HEpositivedirectionReconoiseD4 \b");
19419  HEpositivedirectionReconoiseD4->SetMarkerColor(2);
19420  HEpositivedirectionReconoiseD4->SetLineColor(0);
19421  gPad->SetGridy();
19422  gPad->SetGridx();
19423  // gPad->SetLogy();
19424  if (kcountHEpositivedirectionReconoiseD4 == 1)
19425  HEpositivedirectionReconoiseD4->SetXTitle("D for HE+ jeta = 15; depth = 4 \b");
19426  if (kcountHEpositivedirectionReconoiseD4 == 2)
19427  HEpositivedirectionReconoiseD4->SetXTitle("D for HE+ jeta = 17; depth = 4 \b");
19428  if (kcountHEpositivedirectionReconoiseD4 == 3)
19429  HEpositivedirectionReconoiseD4->SetXTitle("D for HE+ jeta = 18; depth = 4 \b");
19430  if (kcountHEpositivedirectionReconoiseD4 == 4)
19431  HEpositivedirectionReconoiseD4->SetXTitle("D for HE+ jeta = 19; depth = 4 \b");
19432  if (kcountHEpositivedirectionReconoiseD4 == 5)
19433  HEpositivedirectionReconoiseD4->SetXTitle("D for HE+ jeta = 20; depth = 4 \b");
19434  if (kcountHEpositivedirectionReconoiseD4 == 6)
19435  HEpositivedirectionReconoiseD4->SetXTitle("D for HE+ jeta = 21; depth = 4 \b");
19436  if (kcountHEpositivedirectionReconoiseD4 == 7)
19437  HEpositivedirectionReconoiseD4->SetXTitle("D for HE+ jeta = 22; depth = 4 \b");
19438  if (kcountHEpositivedirectionReconoiseD4 == 8)
19439  HEpositivedirectionReconoiseD4->SetXTitle("D for HE+ jeta = 23; depth = 4 \b");
19440  if (kcountHEpositivedirectionReconoiseD4 == 9)
19441  HEpositivedirectionReconoiseD4->SetXTitle("D for HE+ jeta = 24; depth = 4 \b");
19442  if (kcountHEpositivedirectionReconoiseD4 == 10)
19443  HEpositivedirectionReconoiseD4->SetXTitle("D for HE+ jeta = 25; depth = 4 \b");
19444  if (kcountHEpositivedirectionReconoiseD4 == 11)
19445  HEpositivedirectionReconoiseD4->SetXTitle("D for HE+ jeta = 26; depth = 4 \b");
19446  if (kcountHEpositivedirectionReconoiseD4 == 12)
19447  HEpositivedirectionReconoiseD4->SetXTitle("D for HE+ jeta = 27; depth = 4 \b");
19448  HEpositivedirectionReconoiseD4->Draw("Error");
19449  kcountHEpositivedirectionReconoiseD4++;
19450  if (kcountHEpositivedirectionReconoiseD4 > 12)
19451  break; // 4x6 = 24
19452  } //ccctest>0
19453 
19454  } // for i
19455  } //if(jeta-41 >= 0)
19456  } //for jeta
19458  c3x5->Update();
19459  c3x5->Print("DreconoisePositiveDirectionhistD1PhiSymmetryDepth4HE.png");
19460  c3x5->Clear();
19461  // clean-up
19462  if (h2CeffHEpositivedirectionReconoiseD4)
19463  delete h2CeffHEpositivedirectionReconoiseD4;
19464  //========================================================================================== 18
19465  //======================================================================
19466  //======================================================================1D plot: D vs phi , different eta, depth=5
19467  //cout<<" 1D plot: D vs phi , different eta, depth=5 *****" <<endl;
19468  c3x5->Clear();
19469  c3x5->Divide(3, 5);
19470  c3x5->cd(1);
19471  int kcountHEpositivedirectionReconoiseD5 = 1;
19472  TH1F *h2CeffHEpositivedirectionReconoiseD5 = new TH1F("h2CeffHEpositivedirectionReconoiseD5", "", nphi, 0., 72.);
19473 
19474  for (int jeta = 0; jeta < njeta; jeta++) {
19475  // positivedirectionReconoiseD:
19476  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
19477  // for (int i=0;i<ndepth;i++) {
19478  // depth=5
19479  for (int i = 4; i < 5; i++) {
19480  TH1F *HEpositivedirectionReconoiseD5 = (TH1F *)h2CeffHEpositivedirectionReconoiseD5->Clone("twod1");
19481 
19482  float ccctest = 0; // to avoid empty massive elements
19483  for (int jphi = 0; jphi < nphi; jphi++) {
19484  double ccc1 = reconoisevariancehe[i][jeta][jphi];
19485  if (areconoisehe[i][jeta][jphi] > 0.) {
19486  HEpositivedirectionReconoiseD5->Fill(jphi, ccc1);
19487  ccctest = 1.; //HEpositivedirectionReconoiseD5->SetBinError(i,0.01);
19488  }
19489  } // for jphi
19490  if (ccctest > 0.) {
19491  //cout<<"1818 kcountHEpositivedirectionReconoiseD5 = "<<kcountHEpositivedirectionReconoiseD5 <<" jeta-41= "<< jeta-41 <<endl;
19492  c3x5->cd(kcountHEpositivedirectionReconoiseD5);
19493  HEpositivedirectionReconoiseD5->SetMarkerStyle(20);
19494  HEpositivedirectionReconoiseD5->SetMarkerSize(0.4);
19495  HEpositivedirectionReconoiseD5->GetYaxis()->SetLabelSize(0.04);
19496  HEpositivedirectionReconoiseD5->SetXTitle("HEpositivedirectionReconoiseD5 \b");
19497  HEpositivedirectionReconoiseD5->SetMarkerColor(2);
19498  HEpositivedirectionReconoiseD5->SetLineColor(0);
19499  gPad->SetGridy();
19500  gPad->SetGridx();
19501  // gPad->SetLogy();
19502  if (kcountHEpositivedirectionReconoiseD5 == 1)
19503  HEpositivedirectionReconoiseD5->SetXTitle("D for HE+ jeta = 17; depth = 5 \b");
19504  if (kcountHEpositivedirectionReconoiseD5 == 2)
19505  HEpositivedirectionReconoiseD5->SetXTitle("D for HE+ jeta = 18; depth = 5 \b");
19506  if (kcountHEpositivedirectionReconoiseD5 == 3)
19507  HEpositivedirectionReconoiseD5->SetXTitle("D for HE+ jeta = 19; depth = 5 \b");
19508  if (kcountHEpositivedirectionReconoiseD5 == 4)
19509  HEpositivedirectionReconoiseD5->SetXTitle("D for HE+ jeta = 20; depth = 5 \b");
19510  if (kcountHEpositivedirectionReconoiseD5 == 5)
19511  HEpositivedirectionReconoiseD5->SetXTitle("D for HE+ jeta = 21; depth = 5 \b");
19512  if (kcountHEpositivedirectionReconoiseD5 == 6)
19513  HEpositivedirectionReconoiseD5->SetXTitle("D for HE+ jeta = 22; depth = 5 \b");
19514  if (kcountHEpositivedirectionReconoiseD5 == 7)
19515  HEpositivedirectionReconoiseD5->SetXTitle("D for HE+ jeta = 23; depth = 5 \b");
19516  if (kcountHEpositivedirectionReconoiseD5 == 8)
19517  HEpositivedirectionReconoiseD5->SetXTitle("D for HE+ jeta = 24; depth = 5 \b");
19518  if (kcountHEpositivedirectionReconoiseD5 == 9)
19519  HEpositivedirectionReconoiseD5->SetXTitle("D for HE+ jeta = 25; depth = 5 \b");
19520  if (kcountHEpositivedirectionReconoiseD5 == 10)
19521  HEpositivedirectionReconoiseD5->SetXTitle("D for HE+ jeta = 26; depth = 5 \b");
19522  if (kcountHEpositivedirectionReconoiseD5 == 11)
19523  HEpositivedirectionReconoiseD5->SetXTitle("D for HE+ jeta = 27; depth = 5 \b");
19524  HEpositivedirectionReconoiseD5->Draw("Error");
19525  kcountHEpositivedirectionReconoiseD5++;
19526  if (kcountHEpositivedirectionReconoiseD5 > 11)
19527  break; // 4x6 = 24
19528  } //ccctest>0
19529 
19530  } // for i
19531  } //if(jeta-41 >= 0)
19532  } //for jeta
19534  c3x5->Update();
19535  c3x5->Print("DreconoisePositiveDirectionhistD1PhiSymmetryDepth5HE.png");
19536  c3x5->Clear();
19537  // clean-up
19538  if (h2CeffHEpositivedirectionReconoiseD5)
19539  delete h2CeffHEpositivedirectionReconoiseD5;
19540  //========================================================================================== 19
19541  //======================================================================
19542  //======================================================================1D plot: D vs phi , different eta, depth=6
19543  //cout<<" 1D plot: D vs phi , different eta, depth=6 *****" <<endl;
19544  c3x5->Clear();
19545  c3x5->Divide(3, 5);
19546  c3x5->cd(1);
19547  int kcountHEpositivedirectionReconoiseD6 = 1;
19548  TH1F *h2CeffHEpositivedirectionReconoiseD6 = new TH1F("h2CeffHEpositivedirectionReconoiseD6", "", nphi, 0., 72.);
19549 
19550  for (int jeta = 0; jeta < njeta; jeta++) {
19551  // positivedirectionReconoiseD:
19552  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
19553  // for (int i=0;i<ndepth;i++) {
19554  // depth=6
19555  for (int i = 5; i < 6; i++) {
19556  TH1F *HEpositivedirectionReconoiseD6 = (TH1F *)h2CeffHEpositivedirectionReconoiseD6->Clone("twod1");
19557 
19558  float ccctest = 0; // to avoid empty massive elements
19559  for (int jphi = 0; jphi < nphi; jphi++) {
19560  double ccc1 = reconoisevariancehe[i][jeta][jphi];
19561  if (areconoisehe[i][jeta][jphi] > 0.) {
19562  HEpositivedirectionReconoiseD6->Fill(jphi, ccc1);
19563  ccctest = 1.; //HEpositivedirectionReconoiseD6->SetBinError(i,0.01);
19564  }
19565  } // for jphi
19566  if (ccctest > 0.) {
19567  //cout<<"1919 kcountHEpositivedirectionReconoiseD6 = "<<kcountHEpositivedirectionReconoiseD6 <<" jeta-41= "<< jeta-41 <<endl;
19568  c3x5->cd(kcountHEpositivedirectionReconoiseD6);
19569  HEpositivedirectionReconoiseD6->SetMarkerStyle(20);
19570  HEpositivedirectionReconoiseD6->SetMarkerSize(0.4);
19571  HEpositivedirectionReconoiseD6->GetYaxis()->SetLabelSize(0.04);
19572  HEpositivedirectionReconoiseD6->SetXTitle("HEpositivedirectionReconoiseD6 \b");
19573  HEpositivedirectionReconoiseD6->SetMarkerColor(2);
19574  HEpositivedirectionReconoiseD6->SetLineColor(0);
19575  gPad->SetGridy();
19576  gPad->SetGridx();
19577  // gPad->SetLogy();
19578  if (kcountHEpositivedirectionReconoiseD6 == 1)
19579  HEpositivedirectionReconoiseD6->SetXTitle("D for HE+ jeta = 18; depth = 6 \b");
19580  if (kcountHEpositivedirectionReconoiseD6 == 2)
19581  HEpositivedirectionReconoiseD6->SetXTitle("D for HE+ jeta = 19; depth = 6 \b");
19582  if (kcountHEpositivedirectionReconoiseD6 == 3)
19583  HEpositivedirectionReconoiseD6->SetXTitle("D for HE+ jeta = 20; depth = 6 \b");
19584  if (kcountHEpositivedirectionReconoiseD6 == 4)
19585  HEpositivedirectionReconoiseD6->SetXTitle("D for HE+ jeta = 21; depth = 6 \b");
19586  if (kcountHEpositivedirectionReconoiseD6 == 5)
19587  HEpositivedirectionReconoiseD6->SetXTitle("D for HE+ jeta = 22; depth = 6 \b");
19588  if (kcountHEpositivedirectionReconoiseD6 == 6)
19589  HEpositivedirectionReconoiseD6->SetXTitle("D for HE+ jeta = 23; depth = 6 \b");
19590  if (kcountHEpositivedirectionReconoiseD6 == 7)
19591  HEpositivedirectionReconoiseD6->SetXTitle("D for HE+ jeta = 24; depth = 6 \b");
19592  if (kcountHEpositivedirectionReconoiseD6 == 8)
19593  HEpositivedirectionReconoiseD6->SetXTitle("D for HE+ jeta = 25; depth = 6 \b");
19594  if (kcountHEpositivedirectionReconoiseD6 == 9)
19595  HEpositivedirectionReconoiseD6->SetXTitle("D for HE+ jeta = 26; depth = 6 \b");
19596  if (kcountHEpositivedirectionReconoiseD6 == 10)
19597  HEpositivedirectionReconoiseD6->SetXTitle("D for HE+ jeta = 27; depth = 6 \b");
19598  HEpositivedirectionReconoiseD6->Draw("Error");
19599  kcountHEpositivedirectionReconoiseD6++;
19600  if (kcountHEpositivedirectionReconoiseD6 > 10)
19601  break; // 4x6 = 24
19602  } //ccctest>0
19603 
19604  } // for i
19605  } //if(jeta-41 >= 0)
19606  } //for jeta
19608  c3x5->Update();
19609  c3x5->Print("DreconoisePositiveDirectionhistD1PhiSymmetryDepth6HE.png");
19610  c3x5->Clear();
19611  // clean-up
19612  if (h2CeffHEpositivedirectionReconoiseD6)
19613  delete h2CeffHEpositivedirectionReconoiseD6;
19614  //========================================================================================== 20
19615  //======================================================================
19616  //======================================================================1D plot: D vs phi , different eta, depth=7
19617  //cout<<" 1D plot: D vs phi , different eta, depth=7 *****" <<endl;
19618  c3x5->Clear();
19619  c3x5->Divide(3, 5);
19620  c3x5->cd(1);
19621  int kcountHEpositivedirectionReconoiseD7 = 1;
19622  TH1F *h2CeffHEpositivedirectionReconoiseD7 = new TH1F("h2CeffHEpositivedirectionReconoiseD7", "", nphi, 0., 72.);
19623 
19624  for (int jeta = 0; jeta < njeta; jeta++) {
19625  // positivedirectionReconoiseD:
19626  if (jeta - 41 >= 15 && jeta - 41 <= 28) {
19627  // for (int i=0;i<ndepth;i++) {
19628  // depth=7
19629  for (int i = 6; i < 7; i++) {
19630  TH1F *HEpositivedirectionReconoiseD7 = (TH1F *)h2CeffHEpositivedirectionReconoiseD7->Clone("twod1");
19631 
19632  float ccctest = 0; // to avoid empty massive elements
19633  for (int jphi = 0; jphi < nphi; jphi++) {
19634  double ccc1 = reconoisevariancehe[i][jeta][jphi];
19635  if (areconoisehe[i][jeta][jphi] > 0.) {
19636  HEpositivedirectionReconoiseD7->Fill(jphi, ccc1);
19637  ccctest = 1.; //HEpositivedirectionReconoiseD7->SetBinError(i,0.01);
19638  }
19639  } // for jphi
19640  if (ccctest != 0.) {
19641  //cout<<"2020 kcountHEpositivedirectionReconoiseD7 = "<<kcountHEpositivedirectionReconoiseD7 <<" jeta-41= "<< jeta-41 <<endl;
19642  c3x5->cd(kcountHEpositivedirectionReconoiseD7);
19643  HEpositivedirectionReconoiseD7->SetMarkerStyle(20);
19644  HEpositivedirectionReconoiseD7->SetMarkerSize(0.4);
19645  HEpositivedirectionReconoiseD7->GetYaxis()->SetLabelSize(0.04);
19646  HEpositivedirectionReconoiseD7->SetXTitle("HEpositivedirectionReconoiseD7 \b");
19647  HEpositivedirectionReconoiseD7->SetMarkerColor(2);
19648  HEpositivedirectionReconoiseD7->SetLineColor(0);
19649  gPad->SetGridy();
19650  gPad->SetGridx();
19651  // gPad->SetLogy();
19652  if (kcountHEpositivedirectionReconoiseD7 == 1)
19653  HEpositivedirectionReconoiseD7->SetXTitle("D for HE+ jeta = 25; depth = 7 \b");
19654  if (kcountHEpositivedirectionReconoiseD7 == 2)
19655  HEpositivedirectionReconoiseD7->SetXTitle("D for HE+ jeta = 26; depth = 7 \b");
19656  if (kcountHEpositivedirectionReconoiseD7 == 3)
19657  HEpositivedirectionReconoiseD7->SetXTitle("D for HE+ jeta = 27; depth = 7 \b");
19658  HEpositivedirectionReconoiseD7->Draw("Error");
19659  kcountHEpositivedirectionReconoiseD7++;
19660  if (kcountHEpositivedirectionReconoiseD7 > 3)
19661  break; // 4x6 = 24
19662  } //ccctest>0
19663 
19664  } // for i
19665  } //if(jeta-41 >= 0)
19666  } //for jeta
19668  c3x5->Update();
19669  c3x5->Print("DreconoisePositiveDirectionhistD1PhiSymmetryDepth7HE.png");
19670  c3x5->Clear();
19671  // clean-up
19672  if (h2CeffHEpositivedirectionReconoiseD7)
19673  delete h2CeffHEpositivedirectionReconoiseD7;
19674 
19675  //========================================================================================== 22222214
19676  //======================================================================
19677  //======================================================================1D plot: D vs phi , different eta, depth=1
19678  //cout<<" 1D plot: D vs phi , different eta, depth=1 *****" <<endl;
19679  c3x5->Clear();
19681  c3x5->Divide(3, 5);
19682  c3x5->cd(1);
19683  int kcountHEnegativedirectionReconoiseD1 = 1;
19684  TH1F *h2CeffHEnegativedirectionReconoiseD1 = new TH1F("h2CeffHEnegativedirectionReconoiseD1", "", nphi, 0., 72.);
19685 
19686  for (int jeta = 0; jeta < njeta; jeta++) {
19687  // negativedirectionReconoiseD:
19688  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
19689  // for (int i=0;i<ndepth;i++) {
19690  // depth=1
19691  for (int i = 0; i < 1; i++) {
19692  TH1F *HEnegativedirectionReconoiseD1 = (TH1F *)h2CeffHEnegativedirectionReconoiseD1->Clone("twod1");
19693 
19694  float ccctest = 0; // to avoid empty massive elements
19695  for (int jphi = 0; jphi < nphi; jphi++) {
19696  double ccc1 = reconoisevariancehe[i][jeta][jphi];
19697  if (areconoisehe[i][jeta][jphi] > 0.) {
19698  HEnegativedirectionReconoiseD1->Fill(jphi, ccc1);
19699  ccctest = 1.; //HEnegativedirectionReconoiseD1->SetBinError(i,0.01);
19700  }
19701  } // for jphi
19702  if (ccctest > 0.) {
19703  //cout<<"1414 kcountHEnegativedirectionReconoiseD1 = "<<kcountHEnegativedirectionReconoiseD1 <<" jeta-41= "<< jeta-41 <<endl;
19704  c3x5->cd(kcountHEnegativedirectionReconoiseD1);
19705  HEnegativedirectionReconoiseD1->SetMarkerStyle(20);
19706  HEnegativedirectionReconoiseD1->SetMarkerSize(0.4);
19707  HEnegativedirectionReconoiseD1->GetYaxis()->SetLabelSize(0.04);
19708  HEnegativedirectionReconoiseD1->SetXTitle("HEnegativedirectionReconoiseD1 \b");
19709  HEnegativedirectionReconoiseD1->SetMarkerColor(2);
19710  HEnegativedirectionReconoiseD1->SetLineColor(0);
19711  gPad->SetGridy();
19712  gPad->SetGridx();
19713  // gPad->SetLogy();
19714  if (kcountHEnegativedirectionReconoiseD1 == 1)
19715  HEnegativedirectionReconoiseD1->SetXTitle("D for HE- jeta =-29; depth = 1 \b");
19716  if (kcountHEnegativedirectionReconoiseD1 == 2)
19717  HEnegativedirectionReconoiseD1->SetXTitle("D for HE- jeta =-28; depth = 1 \b");
19718  if (kcountHEnegativedirectionReconoiseD1 == 3)
19719  HEnegativedirectionReconoiseD1->SetXTitle("D for HE- jeta =-27; depth = 1 \b");
19720  if (kcountHEnegativedirectionReconoiseD1 == 4)
19721  HEnegativedirectionReconoiseD1->SetXTitle("D for HE- jeta =-26; depth = 1 \b");
19722  if (kcountHEnegativedirectionReconoiseD1 == 5)
19723  HEnegativedirectionReconoiseD1->SetXTitle("D for HE- jeta =-25; depth = 1 \b");
19724  if (kcountHEnegativedirectionReconoiseD1 == 6)
19725  HEnegativedirectionReconoiseD1->SetXTitle("D for HE- jeta =-24; depth = 1 \b");
19726  if (kcountHEnegativedirectionReconoiseD1 == 7)
19727  HEnegativedirectionReconoiseD1->SetXTitle("D for HE- jeta =-23; depth = 1 \b");
19728  if (kcountHEnegativedirectionReconoiseD1 == 8)
19729  HEnegativedirectionReconoiseD1->SetXTitle("D for HE- jeta =-22; depth = 1 \b");
19730  if (kcountHEnegativedirectionReconoiseD1 == 9)
19731  HEnegativedirectionReconoiseD1->SetXTitle("D for HE- jeta =-21; depth = 1 \b");
19732  if (kcountHEnegativedirectionReconoiseD1 == 10)
19733  HEnegativedirectionReconoiseD1->SetXTitle("D for HE- jeta =-20; depth = 1 \b");
19734  if (kcountHEnegativedirectionReconoiseD1 == 11)
19735  HEnegativedirectionReconoiseD1->SetXTitle("D for HE- jeta =-19; depth = 1 \b");
19736  if (kcountHEnegativedirectionReconoiseD1 == 12)
19737  HEnegativedirectionReconoiseD1->SetXTitle("D for HE- jeta =-18; depth = 1 \b");
19738  HEnegativedirectionReconoiseD1->Draw("Error");
19739  kcountHEnegativedirectionReconoiseD1++;
19740  if (kcountHEnegativedirectionReconoiseD1 > 12)
19741  break; // 4x6 = 24
19742  } //ccctest>0
19743 
19744  } // for i
19745  } //if(jeta-41 < 0)
19746  } //for jeta
19748  c3x5->Update();
19749  c3x5->Print("DreconoiseNegativeDirectionhistD1PhiSymmetryDepth1HE.png");
19750  c3x5->Clear();
19751  // clean-up
19752  if (h2CeffHEnegativedirectionReconoiseD1)
19753  delete h2CeffHEnegativedirectionReconoiseD1;
19754  //========================================================================================== 22222215
19755  //======================================================================
19756  //======================================================================1D plot: D vs phi , different eta, depth=2
19757  //cout<<" 1D plot: D vs phi , different eta, depth=2 *****" <<endl;
19758  c3x5->Clear();
19759  c3x5->Divide(3, 5);
19760  c3x5->cd(1);
19761  int kcountHEnegativedirectionReconoiseD2 = 1;
19762  TH1F *h2CeffHEnegativedirectionReconoiseD2 = new TH1F("h2CeffHEnegativedirectionReconoiseD2", "", nphi, 0., 72.);
19763 
19764  for (int jeta = 0; jeta < njeta; jeta++) {
19765  // negativedirectionReconoiseD:
19766  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
19767  // for (int i=0;i<ndepth;i++) {
19768  // depth=2
19769  for (int i = 1; i < 2; i++) {
19770  TH1F *HEnegativedirectionReconoiseD2 = (TH1F *)h2CeffHEnegativedirectionReconoiseD2->Clone("twod1");
19771 
19772  float ccctest = 0; // to avoid empty massive elements
19773  for (int jphi = 0; jphi < nphi; jphi++) {
19774  double ccc1 = reconoisevariancehe[i][jeta][jphi];
19775  if (areconoisehe[i][jeta][jphi] > 0.) {
19776  HEnegativedirectionReconoiseD2->Fill(jphi, ccc1);
19777  ccctest = 1.; //HEnegativedirectionReconoiseD2->SetBinError(i,0.01);
19778  }
19779  } // for jphi
19780  if (ccctest > 0.) {
19781  //cout<<"1515 kcountHEnegativedirectionReconoiseD2 = "<<kcountHEnegativedirectionReconoiseD2 <<" jeta-41= "<< jeta-41 <<endl;
19782  c3x5->cd(kcountHEnegativedirectionReconoiseD2);
19783  HEnegativedirectionReconoiseD2->SetMarkerStyle(20);
19784  HEnegativedirectionReconoiseD2->SetMarkerSize(0.4);
19785  HEnegativedirectionReconoiseD2->GetYaxis()->SetLabelSize(0.04);
19786  HEnegativedirectionReconoiseD2->SetXTitle("HEnegativedirectionReconoiseD2 \b");
19787  HEnegativedirectionReconoiseD2->SetMarkerColor(2);
19788  HEnegativedirectionReconoiseD2->SetLineColor(0);
19789  gPad->SetGridy();
19790  gPad->SetGridx();
19791  // gPad->SetLogy();
19792  if (kcountHEnegativedirectionReconoiseD2 == 1)
19793  HEnegativedirectionReconoiseD2->SetXTitle("D for HE- jeta =-29; depth = 2 \b");
19794  if (kcountHEnegativedirectionReconoiseD2 == 2)
19795  HEnegativedirectionReconoiseD2->SetXTitle("D for HE- jeta =-28; depth = 2 \b");
19796  if (kcountHEnegativedirectionReconoiseD2 == 3)
19797  HEnegativedirectionReconoiseD2->SetXTitle("D for HE- jeta =-27; depth = 2 \b");
19798  if (kcountHEnegativedirectionReconoiseD2 == 4)
19799  HEnegativedirectionReconoiseD2->SetXTitle("D for HE- jeta =-26; depth = 2 \b");
19800  if (kcountHEnegativedirectionReconoiseD2 == 5)
19801  HEnegativedirectionReconoiseD2->SetXTitle("D for HE- jeta =-25; depth = 2 \b");
19802  if (kcountHEnegativedirectionReconoiseD2 == 6)
19803  HEnegativedirectionReconoiseD2->SetXTitle("D for HE- jeta =-24; depth = 2 \b");
19804  if (kcountHEnegativedirectionReconoiseD2 == 7)
19805  HEnegativedirectionReconoiseD2->SetXTitle("D for HE- jeta =-23; depth = 2 \b");
19806  if (kcountHEnegativedirectionReconoiseD2 == 8)
19807  HEnegativedirectionReconoiseD2->SetXTitle("D for HE- jeta =-22; depth = 2 \b");
19808  if (kcountHEnegativedirectionReconoiseD2 == 9)
19809  HEnegativedirectionReconoiseD2->SetXTitle("D for HE- jeta =-21; depth = 2 \b");
19810  if (kcountHEnegativedirectionReconoiseD2 == 10)
19811  HEnegativedirectionReconoiseD2->SetXTitle("D for HE- jeta =-20; depth = 2 \b");
19812  if (kcountHEnegativedirectionReconoiseD2 == 11)
19813  HEnegativedirectionReconoiseD2->SetXTitle("D for HE- jeta =-19; depth = 2 \b");
19814  if (kcountHEnegativedirectionReconoiseD2 == 12)
19815  HEnegativedirectionReconoiseD2->SetXTitle("D for HE- jeta =-18; depth = 2 \b");
19816  if (kcountHEnegativedirectionReconoiseD2 == 13)
19817  HEnegativedirectionReconoiseD2->SetXTitle("D for HE- jeta =-17; depth = 2 \b");
19818  HEnegativedirectionReconoiseD2->Draw("Error");
19819  kcountHEnegativedirectionReconoiseD2++;
19820  if (kcountHEnegativedirectionReconoiseD2 > 13)
19821  break; // 4x6 = 24
19822  } //ccctest>0
19823 
19824  } // for i
19825  } //if(jeta-41 < 0)
19826  } //for jeta
19828  c3x5->Update();
19829  c3x5->Print("DreconoiseNegativeDirectionhistD1PhiSymmetryDepth2HE.png");
19830  c3x5->Clear();
19831  // clean-up
19832  if (h2CeffHEnegativedirectionReconoiseD2)
19833  delete h2CeffHEnegativedirectionReconoiseD2;
19834  //========================================================================================== 22222216
19835  //======================================================================
19836  //======================================================================1D plot: D vs phi , different eta, depth=3
19837  //cout<<" 1D plot: D vs phi , different eta, depth=3 *****" <<endl;
19838  c3x5->Clear();
19839  c3x5->Divide(3, 5);
19840  c3x5->cd(1);
19841  int kcountHEnegativedirectionReconoiseD3 = 1;
19842  TH1F *h2CeffHEnegativedirectionReconoiseD3 = new TH1F("h2CeffHEnegativedirectionReconoiseD3", "", nphi, 0., 72.);
19843 
19844  for (int jeta = 0; jeta < njeta; jeta++) {
19845  // negativedirectionReconoiseD:
19846  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
19847  // for (int i=0;i<ndepth;i++) {
19848  // depth=3
19849  for (int i = 2; i < 3; i++) {
19850  TH1F *HEnegativedirectionReconoiseD3 = (TH1F *)h2CeffHEnegativedirectionReconoiseD3->Clone("twod1");
19851 
19852  float ccctest = 0; // to avoid empty massive elements
19853  for (int jphi = 0; jphi < nphi; jphi++) {
19854  double ccc1 = reconoisevariancehe[i][jeta][jphi];
19855  if (areconoisehe[i][jeta][jphi] > 0.) {
19856  HEnegativedirectionReconoiseD3->Fill(jphi, ccc1);
19857  ccctest = 1.; //HEnegativedirectionReconoiseD3->SetBinError(i,0.01);
19858  }
19859  } // for jphi
19860  if (ccctest > 0.) {
19861  //cout<<"1616 kcountHEnegativedirectionReconoiseD3 = "<<kcountHEnegativedirectionReconoiseD3 <<" jeta-41= "<< jeta-41 <<endl;
19862  c3x5->cd(kcountHEnegativedirectionReconoiseD3);
19863  HEnegativedirectionReconoiseD3->SetMarkerStyle(20);
19864  HEnegativedirectionReconoiseD3->SetMarkerSize(0.4);
19865  HEnegativedirectionReconoiseD3->GetYaxis()->SetLabelSize(0.04);
19866  HEnegativedirectionReconoiseD3->SetXTitle("HEnegativedirectionReconoiseD3 \b");
19867  HEnegativedirectionReconoiseD3->SetMarkerColor(2);
19868  HEnegativedirectionReconoiseD3->SetLineColor(0);
19869  gPad->SetGridy();
19870  gPad->SetGridx();
19871  // gPad->SetLogy();
19872  if (kcountHEnegativedirectionReconoiseD3 == 1)
19873  HEnegativedirectionReconoiseD3->SetXTitle("D for HE- jeta =-29; depth = 3 \b");
19874  if (kcountHEnegativedirectionReconoiseD3 == 2)
19875  HEnegativedirectionReconoiseD3->SetXTitle("D for HE- jeta =-28; depth = 3 \b");
19876  if (kcountHEnegativedirectionReconoiseD3 == 3)
19877  HEnegativedirectionReconoiseD3->SetXTitle("D for HE- jeta =-27; depth = 3 \b");
19878  if (kcountHEnegativedirectionReconoiseD3 == 4)
19879  HEnegativedirectionReconoiseD3->SetXTitle("D for HE- jeta =-26; depth = 3 \b");
19880  if (kcountHEnegativedirectionReconoiseD3 == 5)
19881  HEnegativedirectionReconoiseD3->SetXTitle("D for HE- jeta =-25; depth = 3 \b");
19882  if (kcountHEnegativedirectionReconoiseD3 == 6)
19883  HEnegativedirectionReconoiseD3->SetXTitle("D for HE- jeta =-24; depth = 3 \b");
19884  if (kcountHEnegativedirectionReconoiseD3 == 7)
19885  HEnegativedirectionReconoiseD3->SetXTitle("D for HE- jeta =-23; depth = 3 \b");
19886  if (kcountHEnegativedirectionReconoiseD3 == 8)
19887  HEnegativedirectionReconoiseD3->SetXTitle("D for HE- jeta =-22; depth = 3 \b");
19888  if (kcountHEnegativedirectionReconoiseD3 == 9)
19889  HEnegativedirectionReconoiseD3->SetXTitle("D for HE- jeta =-21; depth = 3 \b");
19890  if (kcountHEnegativedirectionReconoiseD3 == 10)
19891  HEnegativedirectionReconoiseD3->SetXTitle("D for HE- jeta =-20; depth = 3 \b");
19892  if (kcountHEnegativedirectionReconoiseD3 == 11)
19893  HEnegativedirectionReconoiseD3->SetXTitle("D for HE- jeta =-19; depth = 3 \b");
19894  if (kcountHEnegativedirectionReconoiseD3 == 12)
19895  HEnegativedirectionReconoiseD3->SetXTitle("D for HE- jeta =-18; depth = 3 \b");
19896  if (kcountHEnegativedirectionReconoiseD3 == 13)
19897  HEnegativedirectionReconoiseD3->SetXTitle("D for HE- jeta =-17; depth = 3 \b");
19898  HEnegativedirectionReconoiseD3->Draw("Error");
19899  kcountHEnegativedirectionReconoiseD3++;
19900  if (kcountHEnegativedirectionReconoiseD3 > 13)
19901  break; // 4x6 = 24
19902  } //ccctest>0
19903 
19904  } // for i
19905  } //if(jeta-41 < 0)
19906  } //for jeta
19908  c3x5->Update();
19909  c3x5->Print("DreconoiseNegativeDirectionhistD1PhiSymmetryDepth3HE.png");
19910  c3x5->Clear();
19911  // clean-up
19912  if (h2CeffHEnegativedirectionReconoiseD3)
19913  delete h2CeffHEnegativedirectionReconoiseD3;
19914  //========================================================================================== 22222217
19915  //======================================================================
19916  //======================================================================1D plot: D vs phi , different eta, depth=4
19917  //cout<<" 1D plot: D vs phi , different eta, depth=4 *****" <<endl;
19918  c3x5->Clear();
19919  c3x5->Divide(3, 5);
19920  c3x5->cd(1);
19921  int kcountHEnegativedirectionReconoiseD4 = 1;
19922  TH1F *h2CeffHEnegativedirectionReconoiseD4 = new TH1F("h2CeffHEnegativedirectionReconoiseD4", "", nphi, 0., 72.);
19923 
19924  for (int jeta = 0; jeta < njeta; jeta++) {
19925  // negativedirectionReconoiseD:
19926  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
19927  // for (int i=0;i<ndepth;i++) {
19928  // depth=4
19929  for (int i = 3; i < 4; i++) {
19930  TH1F *HEnegativedirectionReconoiseD4 = (TH1F *)h2CeffHEnegativedirectionReconoiseD4->Clone("twod1");
19931 
19932  float ccctest = 0; // to avoid empty massive elements
19933  for (int jphi = 0; jphi < nphi; jphi++) {
19934  double ccc1 = reconoisevariancehe[i][jeta][jphi];
19935  if (areconoisehe[i][jeta][jphi] > 0.) {
19936  HEnegativedirectionReconoiseD4->Fill(jphi, ccc1);
19937  ccctest = 1.; //HEnegativedirectionReconoiseD4->SetBinError(i,0.01);
19938  }
19939  } // for jphi
19940  if (ccctest > 0.) {
19941  //cout<<"1717 kcountHEnegativedirectionReconoiseD4 = "<<kcountHEnegativedirectionReconoiseD4 <<" jeta-41= "<< jeta-41 <<endl;
19942  c3x5->cd(kcountHEnegativedirectionReconoiseD4);
19943  HEnegativedirectionReconoiseD4->SetMarkerStyle(20);
19944  HEnegativedirectionReconoiseD4->SetMarkerSize(0.4);
19945  HEnegativedirectionReconoiseD4->GetYaxis()->SetLabelSize(0.04);
19946  HEnegativedirectionReconoiseD4->SetXTitle("HEnegativedirectionReconoiseD4 \b");
19947  HEnegativedirectionReconoiseD4->SetMarkerColor(2);
19948  HEnegativedirectionReconoiseD4->SetLineColor(0);
19949  gPad->SetGridy();
19950  gPad->SetGridx();
19951  // gPad->SetLogy();
19952  if (kcountHEnegativedirectionReconoiseD4 == 1)
19953  HEnegativedirectionReconoiseD4->SetXTitle("D for HE- jeta =-28; depth = 4 \b");
19954  if (kcountHEnegativedirectionReconoiseD4 == 2)
19955  HEnegativedirectionReconoiseD4->SetXTitle("D for HE- jeta =-27; depth = 4 \b");
19956  if (kcountHEnegativedirectionReconoiseD4 == 3)
19957  HEnegativedirectionReconoiseD4->SetXTitle("D for HE- jeta =-26; depth = 4 \b");
19958  if (kcountHEnegativedirectionReconoiseD4 == 4)
19959  HEnegativedirectionReconoiseD4->SetXTitle("D for HE- jeta =-25; depth = 4 \b");
19960  if (kcountHEnegativedirectionReconoiseD4 == 5)
19961  HEnegativedirectionReconoiseD4->SetXTitle("D for HE- jeta =-24; depth = 4 \b");
19962  if (kcountHEnegativedirectionReconoiseD4 == 6)
19963  HEnegativedirectionReconoiseD4->SetXTitle("D for HE- jeta =-23; depth = 4 \b");
19964  if (kcountHEnegativedirectionReconoiseD4 == 7)
19965  HEnegativedirectionReconoiseD4->SetXTitle("D for HE- jeta =-22; depth = 4 \b");
19966  if (kcountHEnegativedirectionReconoiseD4 == 8)
19967  HEnegativedirectionReconoiseD4->SetXTitle("D for HE- jeta =-21; depth = 4 \b");
19968  if (kcountHEnegativedirectionReconoiseD4 == 9)
19969  HEnegativedirectionReconoiseD4->SetXTitle("D for HE- jeta =-20; depth = 4 \b");
19970  if (kcountHEnegativedirectionReconoiseD4 == 10)
19971  HEnegativedirectionReconoiseD4->SetXTitle("D for HE- jeta =-19; depth = 4 \b");
19972  if (kcountHEnegativedirectionReconoiseD4 == 11)
19973  HEnegativedirectionReconoiseD4->SetXTitle("D for HE- jeta =-18; depth = 4 \b");
19974  if (kcountHEnegativedirectionReconoiseD4 == 12)
19975  HEnegativedirectionReconoiseD4->SetXTitle("D for HE- jeta =-16; depth = 4 \b");
19976  HEnegativedirectionReconoiseD4->Draw("Error");
19977  kcountHEnegativedirectionReconoiseD4++;
19978  if (kcountHEnegativedirectionReconoiseD4 > 12)
19979  break; // 4x6 = 24
19980  } //ccctest>0
19981 
19982  } // for i
19983  } //if(jeta-41 < 0)
19984  } //for jeta
19986  c3x5->Update();
19987  c3x5->Print("DreconoiseNegativeDirectionhistD1PhiSymmetryDepth4HE.png");
19988  c3x5->Clear();
19989  // clean-up
19990  if (h2CeffHEnegativedirectionReconoiseD4)
19991  delete h2CeffHEnegativedirectionReconoiseD4;
19992  //========================================================================================== 22222218
19993  //======================================================================
19994  //======================================================================1D plot: D vs phi , different eta, depth=5
19995  //cout<<" 1D plot: D vs phi , different eta, depth=5 *****" <<endl;
19996  c3x5->Clear();
19997  c3x5->Divide(3, 5);
19998  c3x5->cd(1);
19999  int kcountHEnegativedirectionReconoiseD5 = 1;
20000  TH1F *h2CeffHEnegativedirectionReconoiseD5 = new TH1F("h2CeffHEnegativedirectionReconoiseD5", "", nphi, 0., 72.);
20001 
20002  for (int jeta = 0; jeta < njeta; jeta++) {
20003  // negativedirectionReconoiseD:
20004  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
20005  // for (int i=0;i<ndepth;i++) {
20006  // depth=5
20007  for (int i = 4; i < 5; i++) {
20008  TH1F *HEnegativedirectionReconoiseD5 = (TH1F *)h2CeffHEnegativedirectionReconoiseD5->Clone("twod1");
20009 
20010  float ccctest = 0; // to avoid empty massive elements
20011  for (int jphi = 0; jphi < nphi; jphi++) {
20012  double ccc1 = reconoisevariancehe[i][jeta][jphi];
20013  if (areconoisehe[i][jeta][jphi] > 0.) {
20014  HEnegativedirectionReconoiseD5->Fill(jphi, ccc1);
20015  ccctest = 1.; //HEnegativedirectionReconoiseD5->SetBinError(i,0.01);
20016  }
20017  } // for jphi
20018  if (ccctest > 0.) {
20019  //cout<<"1818 kcountHEnegativedirectionReconoiseD5 = "<<kcountHEnegativedirectionReconoiseD5 <<" jeta-41= "<< jeta-41 <<endl;
20020  c3x5->cd(kcountHEnegativedirectionReconoiseD5);
20021  HEnegativedirectionReconoiseD5->SetMarkerStyle(20);
20022  HEnegativedirectionReconoiseD5->SetMarkerSize(0.4);
20023  HEnegativedirectionReconoiseD5->GetYaxis()->SetLabelSize(0.04);
20024  HEnegativedirectionReconoiseD5->SetXTitle("HEnegativedirectionReconoiseD5 \b");
20025  HEnegativedirectionReconoiseD5->SetMarkerColor(2);
20026  HEnegativedirectionReconoiseD5->SetLineColor(0);
20027  gPad->SetGridy();
20028  gPad->SetGridx();
20029  // gPad->SetLogy();
20030  if (kcountHEnegativedirectionReconoiseD5 == 1)
20031  HEnegativedirectionReconoiseD5->SetXTitle("D for HE- jeta =-28; depth = 5 \b");
20032  if (kcountHEnegativedirectionReconoiseD5 == 2)
20033  HEnegativedirectionReconoiseD5->SetXTitle("D for HE- jeta =-27; depth = 5 \b");
20034  if (kcountHEnegativedirectionReconoiseD5 == 3)
20035  HEnegativedirectionReconoiseD5->SetXTitle("D for HE- jeta =-26; depth = 5 \b");
20036  if (kcountHEnegativedirectionReconoiseD5 == 4)
20037  HEnegativedirectionReconoiseD5->SetXTitle("D for HE- jeta =-25; depth = 5 \b");
20038  if (kcountHEnegativedirectionReconoiseD5 == 5)
20039  HEnegativedirectionReconoiseD5->SetXTitle("D for HE- jeta =-24; depth = 5 \b");
20040  if (kcountHEnegativedirectionReconoiseD5 == 6)
20041  HEnegativedirectionReconoiseD5->SetXTitle("D for HE- jeta =-23; depth = 5 \b");
20042  if (kcountHEnegativedirectionReconoiseD5 == 7)
20043  HEnegativedirectionReconoiseD5->SetXTitle("D for HE- jeta =-22; depth = 5 \b");
20044  if (kcountHEnegativedirectionReconoiseD5 == 8)
20045  HEnegativedirectionReconoiseD5->SetXTitle("D for HE- jeta =-21; depth = 5 \b");
20046  if (kcountHEnegativedirectionReconoiseD5 == 9)
20047  HEnegativedirectionReconoiseD5->SetXTitle("D for HE- jeta =-20; depth = 5 \b");
20048  if (kcountHEnegativedirectionReconoiseD5 == 10)
20049  HEnegativedirectionReconoiseD5->SetXTitle("D for HE- jeta =-19; depth = 5 \b");
20050  if (kcountHEnegativedirectionReconoiseD5 == 11)
20051  HEnegativedirectionReconoiseD5->SetXTitle("D for HE- jeta =-18; depth = 5 \b");
20052  HEnegativedirectionReconoiseD5->Draw("Error");
20053  kcountHEnegativedirectionReconoiseD5++;
20054  if (kcountHEnegativedirectionReconoiseD5 > 11)
20055  break; // 4x6 = 24
20056  } //ccctest>0
20057 
20058  } // for i
20059  } //if(jeta-41 < 0)
20060  } //for jeta
20062  c3x5->Update();
20063  c3x5->Print("DreconoiseNegativeDirectionhistD1PhiSymmetryDepth5HE.png");
20064  c3x5->Clear();
20065  // clean-up
20066  if (h2CeffHEnegativedirectionReconoiseD5)
20067  delete h2CeffHEnegativedirectionReconoiseD5;
20068  //========================================================================================== 22222219
20069  //======================================================================
20070  //======================================================================1D plot: D vs phi , different eta, depth=6
20071  //cout<<" 1D plot: D vs phi , different eta, depth=6 *****" <<endl;
20072  c3x5->Clear();
20073  c3x5->Divide(3, 5);
20074  c3x5->cd(1);
20075  int kcountHEnegativedirectionReconoiseD6 = 1;
20076  TH1F *h2CeffHEnegativedirectionReconoiseD6 = new TH1F("h2CeffHEnegativedirectionReconoiseD6", "", nphi, 0., 72.);
20077 
20078  for (int jeta = 0; jeta < njeta; jeta++) {
20079  // negativedirectionReconoiseD:
20080  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
20081  // for (int i=0;i<ndepth;i++) {
20082  // depth=6
20083  for (int i = 5; i < 6; i++) {
20084  TH1F *HEnegativedirectionReconoiseD6 = (TH1F *)h2CeffHEnegativedirectionReconoiseD6->Clone("twod1");
20085 
20086  float ccctest = 0; // to avoid empty massive elements
20087  for (int jphi = 0; jphi < nphi; jphi++) {
20088  double ccc1 = reconoisevariancehe[i][jeta][jphi];
20089  if (areconoisehe[i][jeta][jphi] > 0.) {
20090  HEnegativedirectionReconoiseD6->Fill(jphi, ccc1);
20091  ccctest = 1.; //HEnegativedirectionReconoiseD6->SetBinError(i,0.01);
20092  }
20093  } // for jphi
20094  if (ccctest > 0.) {
20095  //cout<<"1919 kcountHEnegativedirectionReconoiseD6 = "<<kcountHEnegativedirectionReconoiseD6 <<" jeta-41= "<< jeta-41 <<endl;
20096  c3x5->cd(kcountHEnegativedirectionReconoiseD6);
20097  HEnegativedirectionReconoiseD6->SetMarkerStyle(20);
20098  HEnegativedirectionReconoiseD6->SetMarkerSize(0.4);
20099  HEnegativedirectionReconoiseD6->GetYaxis()->SetLabelSize(0.04);
20100  HEnegativedirectionReconoiseD6->SetXTitle("HEnegativedirectionReconoiseD6 \b");
20101  HEnegativedirectionReconoiseD6->SetMarkerColor(2);
20102  HEnegativedirectionReconoiseD6->SetLineColor(0);
20103  gPad->SetGridy();
20104  gPad->SetGridx();
20105  // gPad->SetLogy();
20106  if (kcountHEnegativedirectionReconoiseD6 == 1)
20107  HEnegativedirectionReconoiseD6->SetXTitle("D for HE- jeta =-28; depth = 6 \b");
20108  if (kcountHEnegativedirectionReconoiseD6 == 2)
20109  HEnegativedirectionReconoiseD6->SetXTitle("D for HE- jeta =-27; depth = 6 \b");
20110  if (kcountHEnegativedirectionReconoiseD6 == 3)
20111  HEnegativedirectionReconoiseD6->SetXTitle("D for HE- jeta =-26; depth = 6 \b");
20112  if (kcountHEnegativedirectionReconoiseD6 == 4)
20113  HEnegativedirectionReconoiseD6->SetXTitle("D for HE- jeta =-25; depth = 6 \b");
20114  if (kcountHEnegativedirectionReconoiseD6 == 5)
20115  HEnegativedirectionReconoiseD6->SetXTitle("D for HE- jeta =-24; depth = 6 \b");
20116  if (kcountHEnegativedirectionReconoiseD6 == 6)
20117  HEnegativedirectionReconoiseD6->SetXTitle("D for HE- jeta =-23; depth = 6 \b");
20118  if (kcountHEnegativedirectionReconoiseD6 == 7)
20119  HEnegativedirectionReconoiseD6->SetXTitle("D for HE- jeta =-22; depth = 6 \b");
20120  if (kcountHEnegativedirectionReconoiseD6 == 8)
20121  HEnegativedirectionReconoiseD6->SetXTitle("D for HE- jeta =-21; depth = 6 \b");
20122  if (kcountHEnegativedirectionReconoiseD6 == 9)
20123  HEnegativedirectionReconoiseD6->SetXTitle("D for HE- jeta =-20; depth = 6 \b");
20124  if (kcountHEnegativedirectionReconoiseD6 == 10)
20125  HEnegativedirectionReconoiseD6->SetXTitle("D for HE- jeta =-19; depth = 6 \b");
20126  HEnegativedirectionReconoiseD6->Draw("Error");
20127  kcountHEnegativedirectionReconoiseD6++;
20128  if (kcountHEnegativedirectionReconoiseD6 > 10)
20129  break; // 4x6 = 24
20130  } //ccctest>0
20131 
20132  } // for i
20133  } //if(jeta-41 < 0)
20134  } //for jeta
20136  c3x5->Update();
20137  c3x5->Print("DreconoiseNegativeDirectionhistD1PhiSymmetryDepth6HE.png");
20138  c3x5->Clear();
20139  // clean-up
20140  if (h2CeffHEnegativedirectionReconoiseD6)
20141  delete h2CeffHEnegativedirectionReconoiseD6;
20142  //========================================================================================== 22222220
20143  //======================================================================
20144  //======================================================================1D plot: D vs phi , different eta, depth=7
20145  //cout<<" 1D plot: D vs phi , different eta, depth=7 *****" <<endl;
20146  c3x5->Clear();
20147  c3x5->Divide(3, 5);
20148  c3x5->cd(1);
20149  int kcountHEnegativedirectionReconoiseD7 = 1;
20150  TH1F *h2CeffHEnegativedirectionReconoiseD7 = new TH1F("h2CeffHEnegativedirectionReconoiseD7", "", nphi, 0., 72.);
20151 
20152  for (int jeta = 0; jeta < njeta; jeta++) {
20153  // negativedirectionReconoiseD:
20154  if (jeta - 41 >= -29 && jeta - 41 <= -16) {
20155  // for (int i=0;i<ndepth;i++) {
20156  // depth=7
20157  for (int i = 6; i < 7; i++) {
20158  TH1F *HEnegativedirectionReconoiseD7 = (TH1F *)h2CeffHEnegativedirectionReconoiseD7->Clone("twod1");
20159 
20160  float ccctest = 0; // to avoid empty massive elements
20161  for (int jphi = 0; jphi < nphi; jphi++) {
20162  double ccc1 = reconoisevariancehe[i][jeta][jphi];
20163  if (areconoisehe[i][jeta][jphi] > 0.) {
20164  HEnegativedirectionReconoiseD7->Fill(jphi, ccc1);
20165  ccctest = 1.; //HEnegativedirectionReconoiseD7->SetBinError(i,0.01);
20166  }
20167  } // for jphi
20168  if (ccctest != 0.) {
20169  //cout<<"2020 kcountHEnegativedirectionReconoiseD7 = "<<kcountHEnegativedirectionReconoiseD7 <<" jeta-41= "<< jeta-41 <<endl;
20170  c3x5->cd(kcountHEnegativedirectionReconoiseD7);
20171  HEnegativedirectionReconoiseD7->SetMarkerStyle(20);
20172  HEnegativedirectionReconoiseD7->SetMarkerSize(0.4);
20173  HEnegativedirectionReconoiseD7->GetYaxis()->SetLabelSize(0.04);
20174  HEnegativedirectionReconoiseD7->SetXTitle("HEnegativedirectionReconoiseD7 \b");
20175  HEnegativedirectionReconoiseD7->SetMarkerColor(2);
20176  HEnegativedirectionReconoiseD7->SetLineColor(0);
20177  gPad->SetGridy();
20178  gPad->SetGridx();
20179  // gPad->SetLogy();
20180  if (kcountHEnegativedirectionReconoiseD7 == 1)
20181  HEnegativedirectionReconoiseD7->SetXTitle("D for HE- jeta =-28; depth = 7 \b");
20182  if (kcountHEnegativedirectionReconoiseD7 == 2)
20183  HEnegativedirectionReconoiseD7->SetXTitle("D for HE- jeta =-27; depth = 7 \b");
20184  if (kcountHEnegativedirectionReconoiseD7 == 3)
20185  HEnegativedirectionReconoiseD7->SetXTitle("D for HE- jeta =-26; depth = 7 \b");
20186  HEnegativedirectionReconoiseD7->Draw("Error");
20187  kcountHEnegativedirectionReconoiseD7++;
20188  if (kcountHEnegativedirectionReconoiseD7 > 3)
20189  break; // 4x6 = 24
20190  } //ccctest>0
20191 
20192  } // for i
20193  } //if(jeta-41 < 0)
20194  } //for jeta
20196  c3x5->Update();
20197  c3x5->Print("DreconoiseNegativeDirectionhistD1PhiSymmetryDepth7HE.png");
20198  c3x5->Clear();
20199  // clean-up
20200  if (h2CeffHEnegativedirectionReconoiseD7)
20201  delete h2CeffHEnegativedirectionReconoiseD7;
20202  //===================================================================== END of Reconoise HE for phi-symmetry
20203  //===================================================================== END of Reconoise HE for phi-symmetry
20204  //===================================================================== END of Reconoise HE for phi-symmetry
20208  // int k_max[5]={0,4,7,4,4}; // maximum depth for each subdet
20209  //ndepth = k_max[5];
20210  ndepth = 2;
20211  double areconoiseHF[ndepth][njeta][njphi];
20212  double breconoiseHF[ndepth][njeta][njphi];
20213  double reconoisevarianceHF[ndepth][njeta][njphi];
20214 
20215  TH2F *recNoiseEnergy1HF1 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy1_HF1");
20216  TH2F *recNoiseEnergy0HF1 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HF1");
20217  TH2F *recNoiseEnergyHF1 = (TH2F *)recNoiseEnergy1HF1->Clone("recNoiseEnergyHF1");
20218  recNoiseEnergyHF1->Divide(recNoiseEnergy1HF1, recNoiseEnergy0HF1, 1, 1, "B");
20219  TH2F *recNoiseEnergy1HF2 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy1_HF2");
20220  TH2F *recNoiseEnergy0HF2 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HF2");
20221  TH2F *recNoiseEnergyHF2 = (TH2F *)recNoiseEnergy1HF2->Clone("recNoiseEnergyHF2");
20222  recNoiseEnergyHF2->Divide(recNoiseEnergy1HF2, recNoiseEnergy0HF2, 1, 1, "B");
20223  //====================================================================== PHI normalization & put R into massive areconoiseHF
20224  for (int jeta = 0; jeta < njeta; jeta++) {
20225  if ((jeta - 41 >= -41 && jeta - 41 <= -29) || (jeta - 41 >= 28 && jeta - 41 <= 40)) {
20226  //preparation for PHI normalization:
20227  double sumreconoiseHF0 = 0;
20228  int nsumreconoiseHF0 = 0;
20229  double sumreconoiseHF1 = 0;
20230  int nsumreconoiseHF1 = 0;
20231  for (int jphi = 0; jphi < njphi; jphi++) {
20232  areconoiseHF[0][jeta][jphi] = recNoiseEnergyHF1->GetBinContent(jeta + 1, jphi + 1);
20233  areconoiseHF[1][jeta][jphi] = recNoiseEnergyHF2->GetBinContent(jeta + 1, jphi + 1);
20234  breconoiseHF[0][jeta][jphi] = recNoiseEnergyHF1->GetBinContent(jeta + 1, jphi + 1);
20235  breconoiseHF[1][jeta][jphi] = recNoiseEnergyHF2->GetBinContent(jeta + 1, jphi + 1);
20236  sumreconoiseHF0 += areconoiseHF[0][jeta][jphi];
20237  ++nsumreconoiseHF0;
20238  sumreconoiseHF1 += areconoiseHF[1][jeta][jphi];
20239  ++nsumreconoiseHF1;
20240  } // phi
20241 
20242  // PHI normalization for DIF:
20243  for (int jphi = 0; jphi < njphi; jphi++) {
20244  if (sumreconoiseHF0 != 0.)
20245  breconoiseHF[0][jeta][jphi] -= (sumreconoiseHF0 / nsumreconoiseHF0);
20246  if (sumreconoiseHF1 != 0.)
20247  breconoiseHF[1][jeta][jphi] -= (sumreconoiseHF1 / nsumreconoiseHF1);
20248  } // phi
20249 
20250  // PHI normalization for R:
20251  for (int jphi = 0; jphi < njphi; jphi++) {
20252  if (sumreconoiseHF0 != 0.)
20253  areconoiseHF[0][jeta][jphi] /= (sumreconoiseHF0 / nsumreconoiseHF0);
20254  if (sumreconoiseHF1 != 0.)
20255  areconoiseHF[1][jeta][jphi] /= (sumreconoiseHF1 / nsumreconoiseHF1);
20256  } // phi
20257 
20258  } // jeta-41
20259  } //eta
20261 
20262  // RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR: Reconoise HF
20263  //------------------------ 2D-eta/phi-plot: R, averaged over depthfs
20264  //======================================================================
20265  //======================================================================
20266  // cout<<" R2D-eta/phi-plot: R, averaged over depthfs *****" <<endl;
20267  c2x1->Clear();
20269  c2x1->Divide(2, 1);
20270  c2x1->cd(1);
20271  TH2F *GefzRreconoiseHF42D = new TH2F("GefzRreconoiseHF42D", "", neta, -41., 41., nphi, 0., 72.);
20272  TH2F *GefzRreconoiseHF42D0 = new TH2F("GefzRreconoiseHF42D0", "", neta, -41., 41., nphi, 0., 72.);
20273  TH2F *GefzRreconoiseHF42DF = (TH2F *)GefzRreconoiseHF42D0->Clone("GefzRreconoiseHF42DF");
20274  for (int i = 0; i < ndepth; i++) {
20275  for (int jeta = 0; jeta < neta; jeta++) {
20276  if ((jeta - 41 >= -41 && jeta - 41 <= -29) || (jeta - 41 >= 28 && jeta - 41 <= 40)) {
20277  for (int jphi = 0; jphi < nphi; jphi++) {
20278  double ccc1 = areconoiseHF[i][jeta][jphi];
20279  int k2plot = jeta - 41;
20280  int kkk = k2plot; //if(k2plot >0 ) kkk=k2plot+1; //-41 +41 !=0
20281  if (ccc1 != 0.) {
20282  GefzRreconoiseHF42D->Fill(kkk, jphi, ccc1);
20283  GefzRreconoiseHF42D0->Fill(kkk, jphi, 1.);
20284  }
20285  }
20286  }
20287  }
20288  }
20289  GefzRreconoiseHF42DF->Divide(GefzRreconoiseHF42D, GefzRreconoiseHF42D0, 1, 1, "B"); // average A
20290  gPad->SetGridy();
20291  gPad->SetGridx(); // gPad->SetLogz();
20292  GefzRreconoiseHF42DF->SetXTitle("<R>_depth #eta \b");
20293  GefzRreconoiseHF42DF->SetYTitle(" #phi \b");
20294  GefzRreconoiseHF42DF->Draw("COLZ");
20295 
20296  c2x1->cd(2);
20297  TH1F *energyhitNoise_HF = (TH1F *)dir->FindObjectAny("h_energyhitNoise_HF");
20298  energyhitNoise_HF->SetMarkerStyle(20);
20299  energyhitNoise_HF->SetMarkerSize(0.4);
20300  energyhitNoise_HF->GetYaxis()->SetLabelSize(0.04);
20301  energyhitNoise_HF->SetXTitle("energyhitNoise_HF \b");
20302  energyhitNoise_HF->SetMarkerColor(2);
20303  energyhitNoise_HF->SetLineColor(0);
20304  gPad->SetGridy();
20305  gPad->SetGridx();
20306  energyhitNoise_HF->Draw("Error");
20307 
20309  c2x1->Update();
20310  c2x1->Print("RreconoiseGeneralD2PhiSymmetryHF.png");
20311  c2x1->Clear();
20312  // clean-up
20313  if (GefzRreconoiseHF42D)
20314  delete GefzRreconoiseHF42D;
20315  if (GefzRreconoiseHF42D0)
20316  delete GefzRreconoiseHF42D0;
20317  if (GefzRreconoiseHF42DF)
20318  delete GefzRreconoiseHF42DF;
20319  //====================================================================== 1D plot: R vs phi , averaged over depthfs & eta
20320  //======================================================================
20321  //cout<<" 1D plot: R vs phi , averaged over depthfs & eta *****" <<endl;
20322  c1x1->Clear();
20324  c1x1->Divide(1, 1);
20325  c1x1->cd(1);
20326  TH1F *GefzRreconoiseHF41D = new TH1F("GefzRreconoiseHF41D", "", nphi, 0., 72.);
20327  TH1F *GefzRreconoiseHF41D0 = new TH1F("GefzRreconoiseHF41D0", "", nphi, 0., 72.);
20328  TH1F *GefzRreconoiseHF41DF = (TH1F *)GefzRreconoiseHF41D0->Clone("GefzRreconoiseHF41DF");
20329  for (int jphi = 0; jphi < nphi; jphi++) {
20330  for (int jeta = 0; jeta < neta; jeta++) {
20331  if ((jeta - 41 >= -41 && jeta - 41 <= -29) || (jeta - 41 >= 28 && jeta - 41 <= 40)) {
20332  for (int i = 0; i < ndepth; i++) {
20333  double ccc1 = areconoiseHF[i][jeta][jphi];
20334  if (ccc1 != 0.) {
20335  GefzRreconoiseHF41D->Fill(jphi, ccc1);
20336  GefzRreconoiseHF41D0->Fill(jphi, 1.);
20337  }
20338  }
20339  }
20340  }
20341  }
20342  GefzRreconoiseHF41DF->Divide(GefzRreconoiseHF41D, GefzRreconoiseHF41D0, 1, 1, "B"); // R averaged over depthfs & eta
20343  GefzRreconoiseHF41D0->Sumw2();
20344  // for (int jphi=1;jphi<73;jphi++) {GefzRreconoiseHF41DF->SetBinError(jphi,0.01);}
20345  gPad->SetGridy();
20346  gPad->SetGridx(); // gPad->SetLogz();
20347  GefzRreconoiseHF41DF->SetMarkerStyle(20);
20348  GefzRreconoiseHF41DF->SetMarkerSize(1.4);
20349  GefzRreconoiseHF41DF->GetZaxis()->SetLabelSize(0.08);
20350  GefzRreconoiseHF41DF->SetXTitle("#phi \b");
20351  GefzRreconoiseHF41DF->SetYTitle(" <R> \b");
20352  GefzRreconoiseHF41DF->SetZTitle("<R>_PHI - AllDepthfs \b");
20353  GefzRreconoiseHF41DF->SetMarkerColor(4);
20354  GefzRreconoiseHF41DF->SetLineColor(
20355  4); // GefzRreconoiseHF41DF->SetMinimum(0.8); // GefzRreconoiseHF41DF->SetMaximum(1.000);
20356  GefzRreconoiseHF41DF->Draw("Error");
20358  c1x1->Update();
20359  c1x1->Print("RreconoiseGeneralD1PhiSymmetryHF.png");
20360  c1x1->Clear();
20361  // clean-up
20362  if (GefzRreconoiseHF41D)
20363  delete GefzRreconoiseHF41D;
20364  if (GefzRreconoiseHF41D0)
20365  delete GefzRreconoiseHF41D0;
20366  if (GefzRreconoiseHF41DF)
20367  delete GefzRreconoiseHF41DF;
20368  //========================================================================================== 4
20369  //======================================================================
20370  //======================================================================1D plot: R vs phi , different eta, depth=1
20371  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
20372  c3x5->Clear();
20374  c3x5->Divide(3, 5);
20375  c3x5->cd(1);
20376  int kcountHFpositivedirectionReconoise1 = 1;
20377  TH1F *h2CeffHFpositivedirectionReconoise1 = new TH1F("h2CeffHFpositivedirectionReconoise1", "", nphi, 0., 72.);
20378  for (int jeta = 0; jeta < njeta; jeta++) {
20379  // positivedirectionReconoise:
20380  if (jeta - 41 >= 28 && jeta - 41 <= 40) {
20381  // for (int i=0;i<ndepth;i++) {
20382  // depth=1
20383  for (int i = 0; i < 1; i++) {
20384  TH1F *HFpositivedirectionReconoise1 = (TH1F *)h2CeffHFpositivedirectionReconoise1->Clone("twod1");
20385  float ccctest = 0; // to avoid empty massive elements
20386  for (int jphi = 0; jphi < nphi; jphi++) {
20387  double ccc1 = areconoiseHF[i][jeta][jphi];
20388  if (ccc1 != 0.) {
20389  HFpositivedirectionReconoise1->Fill(jphi, ccc1);
20390  ccctest = 1.; //HFpositivedirectionReconoise1->SetBinError(i,0.01);
20391  }
20392  } // for jphi
20393  if (ccctest > 0.) {
20394  // cout<<"444 kcountHFpositivedirectionReconoise1 = "<<kcountHFpositivedirectionReconoise1 <<" jeta-41= "<< jeta-41 <<endl;
20395  c3x5->cd(kcountHFpositivedirectionReconoise1);
20396  HFpositivedirectionReconoise1->SetMarkerStyle(20);
20397  HFpositivedirectionReconoise1->SetMarkerSize(0.4);
20398  HFpositivedirectionReconoise1->GetYaxis()->SetLabelSize(0.04);
20399  HFpositivedirectionReconoise1->SetXTitle("HFpositivedirectionReconoise1 \b");
20400  HFpositivedirectionReconoise1->SetMarkerColor(2);
20401  HFpositivedirectionReconoise1->SetLineColor(0);
20402  gPad->SetGridy();
20403  gPad->SetGridx();
20404  // gPad->SetLogy();
20405  if (kcountHFpositivedirectionReconoise1 == 1)
20406  HFpositivedirectionReconoise1->SetXTitle("R for HF+ jeta = 28; depth = 1 \b");
20407  if (kcountHFpositivedirectionReconoise1 == 2)
20408  HFpositivedirectionReconoise1->SetXTitle("R for HF+ jeta = 29; depth = 1 \b");
20409  if (kcountHFpositivedirectionReconoise1 == 3)
20410  HFpositivedirectionReconoise1->SetXTitle("R for HF+ jeta = 30; depth = 1 \b");
20411  if (kcountHFpositivedirectionReconoise1 == 4)
20412  HFpositivedirectionReconoise1->SetXTitle("R for HF+ jeta = 31; depth = 1 \b");
20413  if (kcountHFpositivedirectionReconoise1 == 5)
20414  HFpositivedirectionReconoise1->SetXTitle("R for HF+ jeta = 32; depth = 1 \b");
20415  if (kcountHFpositivedirectionReconoise1 == 6)
20416  HFpositivedirectionReconoise1->SetXTitle("R for HF+ jeta = 33; depth = 1 \b");
20417  if (kcountHFpositivedirectionReconoise1 == 7)
20418  HFpositivedirectionReconoise1->SetXTitle("R for HF+ jeta = 34; depth = 1 \b");
20419  if (kcountHFpositivedirectionReconoise1 == 8)
20420  HFpositivedirectionReconoise1->SetXTitle("R for HF+ jeta = 35; depth = 1 \b");
20421  if (kcountHFpositivedirectionReconoise1 == 9)
20422  HFpositivedirectionReconoise1->SetXTitle("R for HF+ jeta = 36; depth = 1 \b");
20423  if (kcountHFpositivedirectionReconoise1 == 10)
20424  HFpositivedirectionReconoise1->SetXTitle("R for HF+ jeta = 37; depth = 1 \b");
20425  if (kcountHFpositivedirectionReconoise1 == 11)
20426  HFpositivedirectionReconoise1->SetXTitle("R for HF+ jeta = 38; depth = 1 \b");
20427  if (kcountHFpositivedirectionReconoise1 == 12)
20428  HFpositivedirectionReconoise1->SetXTitle("R for HF+ jeta = 39; depth = 1 \b");
20429  if (kcountHFpositivedirectionReconoise1 == 13)
20430  HFpositivedirectionReconoise1->SetXTitle("R for HF+ jeta = 40; depth = 1 \b");
20431  HFpositivedirectionReconoise1->Draw("Error");
20432  kcountHFpositivedirectionReconoise1++;
20433  if (kcountHFpositivedirectionReconoise1 > 13)
20434  break; //
20435  } //ccctest>0
20436 
20437  } // for i
20438  } //if(jeta-41 >= 28 && jeta-41 <= 40
20439  } //for jeta
20441  c3x5->Update();
20442  c3x5->Print("RreconoisePositiveDirectionhistD1PhiSymmetryDepth1HF.png");
20443  c3x5->Clear();
20444  // clean-up
20445  if (h2CeffHFpositivedirectionReconoise1)
20446  delete h2CeffHFpositivedirectionReconoise1;
20447 
20448  //========================================================================================== 5
20449  //======================================================================
20450  //======================================================================1D plot: R vs phi , different eta, depth=2
20451  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
20452  c3x5->Clear();
20454  c3x5->Divide(3, 5);
20455  c3x5->cd(1);
20456  int kcountHFpositivedirectionReconoise2 = 1;
20457  TH1F *h2CeffHFpositivedirectionReconoise2 = new TH1F("h2CeffHFpositivedirectionReconoise2", "", nphi, 0., 72.);
20458  for (int jeta = 0; jeta < njeta; jeta++) {
20459  // positivedirectionReconoise:
20460  if (jeta - 41 >= 28 && jeta - 41 <= 40) {
20461  // for (int i=0;i<ndepth;i++) {
20462  // depth=2
20463  for (int i = 1; i < 2; i++) {
20464  TH1F *HFpositivedirectionReconoise2 = (TH1F *)h2CeffHFpositivedirectionReconoise2->Clone("twod1");
20465  float ccctest = 0; // to avoid empty massive elements
20466  for (int jphi = 0; jphi < nphi; jphi++) {
20467  double ccc1 = areconoiseHF[i][jeta][jphi];
20468  if (ccc1 != 0.) {
20469  HFpositivedirectionReconoise2->Fill(jphi, ccc1);
20470  ccctest = 1.; //HFpositivedirectionReconoise2->SetBinError(i,0.01);
20471  }
20472  } // for jphi
20473  if (ccctest > 0.) {
20474  //cout<<"555 kcountHFpositivedirectionReconoise2 = "<<kcountHFpositivedirectionReconoise2 <<" jeta-41= "<< jeta-41 <<endl;
20475  c3x5->cd(kcountHFpositivedirectionReconoise2);
20476  HFpositivedirectionReconoise2->SetMarkerStyle(20);
20477  HFpositivedirectionReconoise2->SetMarkerSize(0.4);
20478  HFpositivedirectionReconoise2->GetYaxis()->SetLabelSize(0.04);
20479  HFpositivedirectionReconoise2->SetXTitle("HFpositivedirectionReconoise2 \b");
20480  HFpositivedirectionReconoise2->SetMarkerColor(2);
20481  HFpositivedirectionReconoise2->SetLineColor(0);
20482  gPad->SetGridy();
20483  gPad->SetGridx();
20484  // gPad->SetLogy();
20485  if (kcountHFpositivedirectionReconoise2 == 1)
20486  HFpositivedirectionReconoise2->SetXTitle("R for HF+ jeta = 28; depth = 2 \b");
20487  if (kcountHFpositivedirectionReconoise2 == 2)
20488  HFpositivedirectionReconoise2->SetXTitle("R for HF+ jeta = 29; depth = 2 \b");
20489  if (kcountHFpositivedirectionReconoise2 == 3)
20490  HFpositivedirectionReconoise2->SetXTitle("R for HF+ jeta = 30; depth = 2 \b");
20491  if (kcountHFpositivedirectionReconoise2 == 4)
20492  HFpositivedirectionReconoise2->SetXTitle("R for HF+ jeta = 31; depth = 2 \b");
20493  if (kcountHFpositivedirectionReconoise2 == 5)
20494  HFpositivedirectionReconoise2->SetXTitle("R for HF+ jeta = 32; depth = 2 \b");
20495  if (kcountHFpositivedirectionReconoise2 == 6)
20496  HFpositivedirectionReconoise2->SetXTitle("R for HF+ jeta = 33; depth = 2 \b");
20497  if (kcountHFpositivedirectionReconoise2 == 7)
20498  HFpositivedirectionReconoise2->SetXTitle("R for HF+ jeta = 34; depth = 2 \b");
20499  if (kcountHFpositivedirectionReconoise2 == 8)
20500  HFpositivedirectionReconoise2->SetXTitle("R for HF+ jeta = 35; depth = 2 \b");
20501  if (kcountHFpositivedirectionReconoise2 == 9)
20502  HFpositivedirectionReconoise2->SetXTitle("R for HF+ jeta = 36; depth = 2 \b");
20503  if (kcountHFpositivedirectionReconoise2 == 10)
20504  HFpositivedirectionReconoise2->SetXTitle("R for HF+ jeta = 37; depth = 2 \b");
20505  if (kcountHFpositivedirectionReconoise2 == 11)
20506  HFpositivedirectionReconoise2->SetXTitle("R for HF+ jeta = 38; depth = 2 \b");
20507  if (kcountHFpositivedirectionReconoise2 == 12)
20508  HFpositivedirectionReconoise2->SetXTitle("R for HF+ jeta = 39; depth = 2 \b");
20509  if (kcountHFpositivedirectionReconoise2 == 13)
20510  HFpositivedirectionReconoise2->SetXTitle("R for HF+ jeta = 40; depth = 2 \b");
20511  HFpositivedirectionReconoise2->Draw("Error");
20512  kcountHFpositivedirectionReconoise2++;
20513  if (kcountHFpositivedirectionReconoise2 > 13)
20514  break; // 4x6 = 24
20515  } //ccctest>0
20516 
20517  } // for i
20518  } //if(jeta-41 >= 28 && jeta-41 <= 40)
20519  } //for jeta
20521  c3x5->Update();
20522  c3x5->Print("RreconoisePositiveDirectionhistD1PhiSymmetryDepth2HF.png");
20523  c3x5->Clear();
20524  // clean-up
20525  if (h2CeffHFpositivedirectionReconoise2)
20526  delete h2CeffHFpositivedirectionReconoise2;
20527 
20528  //========================================================================================== 1111114
20529  //======================================================================
20530  //======================================================================1D plot: R vs phi , different eta, depth=1
20531  //cout<<" 1D plot: R vs phi , different eta, depth=1 *****" <<endl;
20532  c3x5->Clear();
20534  c3x5->Divide(3, 5);
20535  c3x5->cd(1);
20536  int kcountHFnegativedirectionReconoise1 = 1;
20537  TH1F *h2CeffHFnegativedirectionReconoise1 = new TH1F("h2CeffHFnegativedirectionReconoise1", "", nphi, 0., 72.);
20538  for (int jeta = 0; jeta < njeta; jeta++) {
20539  // negativedirectionReconoise:
20540  if (jeta - 41 >= -41 && jeta - 41 <= -29) {
20541  // for (int i=0;i<ndepth;i++) {
20542  // depth=1
20543  for (int i = 0; i < 1; i++) {
20544  TH1F *HFnegativedirectionReconoise1 = (TH1F *)h2CeffHFnegativedirectionReconoise1->Clone("twod1");
20545  float ccctest = 0; // to avoid empty massive elements
20546  for (int jphi = 0; jphi < nphi; jphi++) {
20547  double ccc1 = areconoiseHF[i][jeta][jphi];
20548  if (ccc1 != 0.) {
20549  HFnegativedirectionReconoise1->Fill(jphi, ccc1);
20550  ccctest = 1.; //HFnegativedirectionReconoise1->SetBinError(i,0.01);
20551  }
20552  } // for jphi
20553  if (ccctest > 0.) {
20554  // cout<<"444 kcountHFnegativedirectionReconoise1 = "<<kcountHFnegativedirectionReconoise1 <<" jeta-41= "<< jeta-41 <<endl;
20555  c3x5->cd(kcountHFnegativedirectionReconoise1);
20556  HFnegativedirectionReconoise1->SetMarkerStyle(20);
20557  HFnegativedirectionReconoise1->SetMarkerSize(0.4);
20558  HFnegativedirectionReconoise1->GetYaxis()->SetLabelSize(0.04);
20559  HFnegativedirectionReconoise1->SetXTitle("HFnegativedirectionReconoise1 \b");
20560  HFnegativedirectionReconoise1->SetMarkerColor(2);
20561  HFnegativedirectionReconoise1->SetLineColor(0);
20562  gPad->SetGridy();
20563  gPad->SetGridx();
20564  // gPad->SetLogy();
20565  if (kcountHFnegativedirectionReconoise1 == 1)
20566  HFnegativedirectionReconoise1->SetXTitle("R for HF- jeta =-41; depth = 1 \b");
20567  if (kcountHFnegativedirectionReconoise1 == 2)
20568  HFnegativedirectionReconoise1->SetXTitle("R for HF- jeta =-40; depth = 1 \b");
20569  if (kcountHFnegativedirectionReconoise1 == 3)
20570  HFnegativedirectionReconoise1->SetXTitle("R for HF- jeta =-39; depth = 1 \b");
20571  if (kcountHFnegativedirectionReconoise1 == 4)
20572  HFnegativedirectionReconoise1->SetXTitle("R for HF- jeta =-38; depth = 1 \b");
20573  if (kcountHFnegativedirectionReconoise1 == 5)
20574  HFnegativedirectionReconoise1->SetXTitle("R for HF- jeta =-37; depth = 1 \b");
20575  if (kcountHFnegativedirectionReconoise1 == 6)
20576  HFnegativedirectionReconoise1->SetXTitle("R for HF- jeta =-36; depth = 1 \b");
20577  if (kcountHFnegativedirectionReconoise1 == 7)
20578  HFnegativedirectionReconoise1->SetXTitle("R for HF- jeta =-35; depth = 1 \b");
20579  if (kcountHFnegativedirectionReconoise1 == 8)
20580  HFnegativedirectionReconoise1->SetXTitle("R for HF- jeta =-34; depth = 1 \b");
20581  if (kcountHFnegativedirectionReconoise1 == 9)
20582  HFnegativedirectionReconoise1->SetXTitle("R for HF- jeta =-33; depth = 1 \b");
20583  if (kcountHFnegativedirectionReconoise1 == 10)
20584  HFnegativedirectionReconoise1->SetXTitle("R for HF- jeta =-32; depth = 1 \b");
20585  if (kcountHFnegativedirectionReconoise1 == 11)
20586  HFnegativedirectionReconoise1->SetXTitle("R for HF- jeta =-31; depth = 1 \b");
20587  if (kcountHFnegativedirectionReconoise1 == 12)
20588  HFnegativedirectionReconoise1->SetXTitle("R for HF- jeta =-30; depth = 1 \b");
20589  if (kcountHFnegativedirectionReconoise1 == 13)
20590  HFnegativedirectionReconoise1->SetXTitle("R for HF- jeta =-29; depth = 1 \b");
20591  HFnegativedirectionReconoise1->Draw("Error");
20592  kcountHFnegativedirectionReconoise1++;
20593  if (kcountHFnegativedirectionReconoise1 > 13)
20594  break; //
20595  } //ccctest>0
20596 
20597  } // for i
20598  } //if(jeta-41 >= -41 && jeta-41 <= -29)
20599  } //for jeta
20601  c3x5->Update();
20602  c3x5->Print("RreconoiseNegativeDirectionhistD1PhiSymmetryDepth1HF.png");
20603  c3x5->Clear();
20604  // clean-up
20605  if (h2CeffHFnegativedirectionReconoise1)
20606  delete h2CeffHFnegativedirectionReconoise1;
20607 
20608  //========================================================================================== 1111115
20609  //======================================================================
20610  //======================================================================1D plot: R vs phi , different eta, depth=2
20611  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
20612  c3x5->Clear();
20614  c3x5->Divide(3, 5);
20615  c3x5->cd(1);
20616  int kcountHFnegativedirectionReconoise2 = 1;
20617  TH1F *h2CeffHFnegativedirectionReconoise2 = new TH1F("h2CeffHFnegativedirectionReconoise2", "", nphi, 0., 72.);
20618  for (int jeta = 0; jeta < njeta; jeta++) {
20619  // negativedirectionReconoise:
20620  if (jeta - 41 >= -41 && jeta - 41 <= -29) {
20621  // for (int i=0;i<ndepth;i++) {
20622  // depth=2
20623  for (int i = 1; i < 2; i++) {
20624  TH1F *HFnegativedirectionReconoise2 = (TH1F *)h2CeffHFnegativedirectionReconoise2->Clone("twod1");
20625  float ccctest = 0; // to avoid empty massive elements
20626  for (int jphi = 0; jphi < nphi; jphi++) {
20627  double ccc1 = areconoiseHF[i][jeta][jphi];
20628  if (ccc1 != 0.) {
20629  HFnegativedirectionReconoise2->Fill(jphi, ccc1);
20630  ccctest = 1.; //HFnegativedirectionReconoise2->SetBinError(i,0.01);
20631  }
20632  } // for jphi
20633  if (ccctest > 0.) {
20634  //cout<<"555 kcountHFnegativedirectionReconoise2 = "<<kcountHFnegativedirectionReconoise2 <<" jeta-41= "<< jeta-41 <<endl;
20635  c3x5->cd(kcountHFnegativedirectionReconoise2);
20636  HFnegativedirectionReconoise2->SetMarkerStyle(20);
20637  HFnegativedirectionReconoise2->SetMarkerSize(0.4);
20638  HFnegativedirectionReconoise2->GetYaxis()->SetLabelSize(0.04);
20639  HFnegativedirectionReconoise2->SetXTitle("HFnegativedirectionReconoise2 \b");
20640  HFnegativedirectionReconoise2->SetMarkerColor(2);
20641  HFnegativedirectionReconoise2->SetLineColor(0);
20642  gPad->SetGridy();
20643  gPad->SetGridx();
20644  // gPad->SetLogy();
20645  if (kcountHFnegativedirectionReconoise2 == 1)
20646  HFnegativedirectionReconoise2->SetXTitle("R for HF- jeta =-41; depth = 2 \b");
20647  if (kcountHFnegativedirectionReconoise2 == 2)
20648  HFnegativedirectionReconoise2->SetXTitle("R for HF- jeta =-40; depth = 2 \b");
20649  if (kcountHFnegativedirectionReconoise2 == 3)
20650  HFnegativedirectionReconoise2->SetXTitle("R for HF- jeta =-39; depth = 2 \b");
20651  if (kcountHFnegativedirectionReconoise2 == 4)
20652  HFnegativedirectionReconoise2->SetXTitle("R for HF- jeta =-38; depth = 2 \b");
20653  if (kcountHFnegativedirectionReconoise2 == 5)
20654  HFnegativedirectionReconoise2->SetXTitle("R for HF- jeta =-37; depth = 2 \b");
20655  if (kcountHFnegativedirectionReconoise2 == 6)
20656  HFnegativedirectionReconoise2->SetXTitle("R for HF- jeta =-36; depth = 2 \b");
20657  if (kcountHFnegativedirectionReconoise2 == 7)
20658  HFnegativedirectionReconoise2->SetXTitle("R for HF- jeta =-35; depth = 2 \b");
20659  if (kcountHFnegativedirectionReconoise2 == 8)
20660  HFnegativedirectionReconoise2->SetXTitle("R for HF- jeta =-34; depth = 2 \b");
20661  if (kcountHFnegativedirectionReconoise2 == 9)
20662  HFnegativedirectionReconoise2->SetXTitle("R for HF- jeta =-33; depth = 2 \b");
20663  if (kcountHFnegativedirectionReconoise2 == 10)
20664  HFnegativedirectionReconoise2->SetXTitle("R for HF- jeta =-32; depth = 2 \b");
20665  if (kcountHFnegativedirectionReconoise2 == 11)
20666  HFnegativedirectionReconoise2->SetXTitle("R for HF- jeta =-31; depth = 2 \b");
20667  if (kcountHFnegativedirectionReconoise2 == 12)
20668  HFnegativedirectionReconoise2->SetXTitle("R for HF- jeta =-30; depth = 2 \b");
20669  if (kcountHFnegativedirectionReconoise2 == 13)
20670  HFnegativedirectionReconoise2->SetXTitle("R for HF- jeta =-20; depth = 2 \b");
20671  HFnegativedirectionReconoise2->Draw("Error");
20672  kcountHFnegativedirectionReconoise2++;
20673  if (kcountHFnegativedirectionReconoise2 > 13)
20674  break; // 4x6 = 24
20675  } //ccctest>0
20676 
20677  } // for i
20678  } //if(jeta-41 >= -41 && jeta-41 <= -29)
20679  } //for jeta
20681  c3x5->Update();
20682  c3x5->Print("RreconoiseNegativeDirectionhistD1PhiSymmetryDepth2HF.png");
20683  c3x5->Clear();
20684  // clean-up
20685  if (h2CeffHFnegativedirectionReconoise2)
20686  delete h2CeffHFnegativedirectionReconoise2;
20687 
20688  //======================================================================================================================
20689  // DIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIF: Reconoise HF
20690  //------------------------ 2D-eta/phi-plot: DIF, averaged over depthfs
20691  //======================================================================
20692  //======================================================================
20693  // cout<<" DIF2D-eta/phi-plot: DIF, averaged over depthfs *****" <<endl;
20694  c2x1->Clear();
20696  c2x1->Divide(2, 1);
20697  c2x1->cd(1);
20698  TH2F *GefzDIFreconoiseHF42D = new TH2F("GefzDIFreconoiseHF42D", "", neta, -41., 41., nphi, 0., 72.);
20699  TH2F *GefzDIFreconoiseHF42D0 = new TH2F("GefzDIFreconoiseHF42D0", "", neta, -41., 41., nphi, 0., 72.);
20700  TH2F *GefzDIFreconoiseHF42DF = (TH2F *)GefzDIFreconoiseHF42D0->Clone("GefzDIFreconoiseHF42DF");
20701  for (int i = 0; i < ndepth; i++) {
20702  for (int jeta = 0; jeta < neta; jeta++) {
20703  if ((jeta - 41 >= -41 && jeta - 41 <= -29) || (jeta - 41 >= 28 && jeta - 41 <= 40)) {
20704  for (int jphi = 0; jphi < nphi; jphi++) {
20705  double ccc1 = breconoiseHF[i][jeta][jphi];
20706  int k2plot = jeta - 41;
20707  int kkk = k2plot; //if(k2plot >0 ) kkk=k2plot+1; //-41 +41 !=0
20708  if (ccc1 != 0.) {
20709  GefzDIFreconoiseHF42D->Fill(kkk, jphi, ccc1);
20710  GefzDIFreconoiseHF42D0->Fill(kkk, jphi, 1.);
20711  }
20712  }
20713  }
20714  }
20715  }
20716  GefzDIFreconoiseHF42DF->Divide(GefzDIFreconoiseHF42D, GefzDIFreconoiseHF42D0, 1, 1, "B"); // average A
20717  gPad->SetGridy();
20718  gPad->SetGridx(); // gPad->SetLogz();
20719  GefzDIFreconoiseHF42DF->SetXTitle("<DIF>_depth #eta \b");
20720  GefzDIFreconoiseHF42DF->SetYTitle(" #phi \b");
20721  GefzDIFreconoiseHF42DF->Draw("COLZ");
20722 
20723  c2x1->cd(2);
20724  // TH1F *energyhitNoiseCut_HF= (TH1F*)dir->FindObjectAny("h_energyhitNoiseCut_HF");
20725  // energyhitNoiseCut_HF ->SetMarkerStyle(20);energyhitNoiseCut_HF ->SetMarkerSize(0.4);energyhitNoiseCut_HF ->GetYaxis()->SetLabelSize(0.04);energyhitNoiseCut_HF ->SetXTitle("energyhitNoiseCut_HF \b");energyhitNoiseCut_HF ->SetMarkerColor(2);energyhitNoiseCut_HF ->SetLineColor(0);gPad->SetGridy();gPad->SetGridx();energyhitNoiseCut_HF ->Draw("Error");
20726 
20728  c2x1->Update();
20729  c2x1->Print("DIFreconoiseGeneralD2PhiSymmetryHF.png");
20730  c2x1->Clear();
20731  // clean-up
20732  if (GefzDIFreconoiseHF42D)
20733  delete GefzDIFreconoiseHF42D;
20734  if (GefzDIFreconoiseHF42D0)
20735  delete GefzDIFreconoiseHF42D0;
20736  if (GefzDIFreconoiseHF42DF)
20737  delete GefzDIFreconoiseHF42DF;
20738  //====================================================================== 1D plot: DIF vs phi , averaged over depthfs & eta
20739  //======================================================================
20740  //cout<<" 1D plot: DIF vs phi , averaged over depthfs & eta *****" <<endl;
20741  c1x1->Clear();
20743  c1x1->Divide(1, 1);
20744  c1x1->cd(1);
20745  TH1F *GefzDIFreconoiseHF41D = new TH1F("GefzDIFreconoiseHF41D", "", nphi, 0., 72.);
20746  TH1F *GefzDIFreconoiseHF41D0 = new TH1F("GefzDIFreconoiseHF41D0", "", nphi, 0., 72.);
20747  TH1F *GefzDIFreconoiseHF41DF = (TH1F *)GefzDIFreconoiseHF41D0->Clone("GefzDIFreconoiseHF41DF");
20748  for (int jphi = 0; jphi < nphi; jphi++) {
20749  for (int jeta = 0; jeta < neta; jeta++) {
20750  if ((jeta - 41 >= -41 && jeta - 41 <= -29) || (jeta - 41 >= 28 && jeta - 41 <= 40)) {
20751  for (int i = 0; i < ndepth; i++) {
20752  double ccc1 = breconoiseHF[i][jeta][jphi];
20753  if (ccc1 != 0.) {
20754  GefzDIFreconoiseHF41D->Fill(jphi, ccc1);
20755  GefzDIFreconoiseHF41D0->Fill(jphi, 1.);
20756  }
20757  }
20758  }
20759  }
20760  }
20761  GefzDIFreconoiseHF41DF->Divide(
20762  GefzDIFreconoiseHF41D, GefzDIFreconoiseHF41D0, 1, 1, "B"); // DIF averaged over depthfs & eta
20763  GefzDIFreconoiseHF41D0->Sumw2();
20764  // for (int jphi=1;jphi<73;jphi++) {GefzDIFreconoiseHF41DF->SetBinError(jphi,0.01);}
20765  gPad->SetGridy();
20766  gPad->SetGridx(); // gPad->SetLogz();
20767  GefzDIFreconoiseHF41DF->SetMarkerStyle(20);
20768  GefzDIFreconoiseHF41DF->SetMarkerSize(1.4);
20769  GefzDIFreconoiseHF41DF->GetZaxis()->SetLabelSize(0.08);
20770  GefzDIFreconoiseHF41DF->SetXTitle("#phi \b");
20771  GefzDIFreconoiseHF41DF->SetYTitle(" <DIF> \b");
20772  GefzDIFreconoiseHF41DF->SetZTitle("<DIF>_PHI - AllDepthfs \b");
20773  GefzDIFreconoiseHF41DF->SetMarkerColor(4);
20774  GefzDIFreconoiseHF41DF->SetLineColor(
20775  4); // GefzDIFreconoiseHF41DF->SetMinimum(0.8); // GefzDIFreconoiseHF41DF->SetMaximum(1.000);
20776  GefzDIFreconoiseHF41DF->Draw("Error");
20778  c1x1->Update();
20779  c1x1->Print("DIFreconoiseGeneralD1PhiSymmetryHF.png");
20780  c1x1->Clear();
20781  // clean-up
20782  if (GefzDIFreconoiseHF41D)
20783  delete GefzDIFreconoiseHF41D;
20784  if (GefzDIFreconoiseHF41D0)
20785  delete GefzDIFreconoiseHF41D0;
20786  if (GefzDIFreconoiseHF41DF)
20787  delete GefzDIFreconoiseHF41DF;
20788  //========================================================================================== 4
20789  //======================================================================
20790  //======================================================================1D plot: DIF vs phi , different eta, depth=1
20791  //cout<<" 1D plot: DIF vs phi , different eta, depth=1 *****" <<endl;
20792  c3x5->Clear();
20794  c3x5->Divide(3, 5);
20795  c3x5->cd(1);
20796  int kcountHFpositivedirectionReconoiseDIF1 = 1;
20797  TH1F *h2CeffHFpositivedirectionReconoiseDIF1 = new TH1F("h2CeffHFpositivedirectionReconoiseDIF1", "", nphi, 0., 72.);
20798  for (int jeta = 0; jeta < njeta; jeta++) {
20799  // positivedirectionReconoiseDIF:
20800  if (jeta - 41 >= 28 && jeta - 41 <= 40) {
20801  // for (int i=0;i<ndepth;i++) {
20802  // depth=1
20803  for (int i = 0; i < 1; i++) {
20804  TH1F *HFpositivedirectionReconoiseDIF1 = (TH1F *)h2CeffHFpositivedirectionReconoiseDIF1->Clone("twod1");
20805  float ccctest = 0; // to avoid empty massive elements
20806  for (int jphi = 0; jphi < nphi; jphi++) {
20807  double ccc1 = breconoiseHF[i][jeta][jphi];
20808  if (ccc1 != 0.) {
20809  HFpositivedirectionReconoiseDIF1->Fill(jphi, ccc1);
20810  ccctest = 1.; //HFpositivedirectionReconoiseDIF1->SetBinError(i,0.01);
20811  }
20812  } // for jphi
20813  if (ccctest > 0.) {
20814  // cout<<"444 kcountHFpositivedirectionReconoiseDIF1 = "<<kcountHFpositivedirectionReconoiseDIF1 <<" jeta-41= "<< jeta-41 <<endl;
20815  c3x5->cd(kcountHFpositivedirectionReconoiseDIF1);
20816  HFpositivedirectionReconoiseDIF1->SetMarkerStyle(20);
20817  HFpositivedirectionReconoiseDIF1->SetMarkerSize(0.4);
20818  HFpositivedirectionReconoiseDIF1->GetYaxis()->SetLabelSize(0.04);
20819  HFpositivedirectionReconoiseDIF1->SetXTitle("HFpositivedirectionReconoiseDIF1 \b");
20820  HFpositivedirectionReconoiseDIF1->SetMarkerColor(2);
20821  HFpositivedirectionReconoiseDIF1->SetLineColor(0);
20822  gPad->SetGridy();
20823  gPad->SetGridx();
20824  // gPad->SetLogy();
20825  if (kcountHFpositivedirectionReconoiseDIF1 == 1)
20826  HFpositivedirectionReconoiseDIF1->SetXTitle("DIF for HF+ jeta = 28; depth = 1 \b");
20827  if (kcountHFpositivedirectionReconoiseDIF1 == 2)
20828  HFpositivedirectionReconoiseDIF1->SetXTitle("DIF for HF+ jeta = 29; depth = 1 \b");
20829  if (kcountHFpositivedirectionReconoiseDIF1 == 3)
20830  HFpositivedirectionReconoiseDIF1->SetXTitle("DIF for HF+ jeta = 30; depth = 1 \b");
20831  if (kcountHFpositivedirectionReconoiseDIF1 == 4)
20832  HFpositivedirectionReconoiseDIF1->SetXTitle("DIF for HF+ jeta = 31; depth = 1 \b");
20833  if (kcountHFpositivedirectionReconoiseDIF1 == 5)
20834  HFpositivedirectionReconoiseDIF1->SetXTitle("DIF for HF+ jeta = 32; depth = 1 \b");
20835  if (kcountHFpositivedirectionReconoiseDIF1 == 6)
20836  HFpositivedirectionReconoiseDIF1->SetXTitle("DIF for HF+ jeta = 33; depth = 1 \b");
20837  if (kcountHFpositivedirectionReconoiseDIF1 == 7)
20838  HFpositivedirectionReconoiseDIF1->SetXTitle("DIF for HF+ jeta = 34; depth = 1 \b");
20839  if (kcountHFpositivedirectionReconoiseDIF1 == 8)
20840  HFpositivedirectionReconoiseDIF1->SetXTitle("DIF for HF+ jeta = 35; depth = 1 \b");
20841  if (kcountHFpositivedirectionReconoiseDIF1 == 9)
20842  HFpositivedirectionReconoiseDIF1->SetXTitle("DIF for HF+ jeta = 36; depth = 1 \b");
20843  if (kcountHFpositivedirectionReconoiseDIF1 == 10)
20844  HFpositivedirectionReconoiseDIF1->SetXTitle("DIF for HF+ jeta = 37; depth = 1 \b");
20845  if (kcountHFpositivedirectionReconoiseDIF1 == 11)
20846  HFpositivedirectionReconoiseDIF1->SetXTitle("DIF for HF+ jeta = 38; depth = 1 \b");
20847  if (kcountHFpositivedirectionReconoiseDIF1 == 12)
20848  HFpositivedirectionReconoiseDIF1->SetXTitle("DIF for HF+ jeta = 39; depth = 1 \b");
20849  if (kcountHFpositivedirectionReconoiseDIF1 == 13)
20850  HFpositivedirectionReconoiseDIF1->SetXTitle("DIF for HF+ jeta = 40; depth = 1 \b");
20851  HFpositivedirectionReconoiseDIF1->Draw("Error");
20852  kcountHFpositivedirectionReconoiseDIF1++;
20853  if (kcountHFpositivedirectionReconoiseDIF1 > 13)
20854  break; //
20855  } //ccctest>0
20856 
20857  } // for i
20858  } //if(jeta-41 >= 28 && jeta-41 <= 40
20859  } //for jeta
20861  c3x5->Update();
20862  c3x5->Print("DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth1HF.png");
20863  c3x5->Clear();
20864  // clean-up
20865  if (h2CeffHFpositivedirectionReconoiseDIF1)
20866  delete h2CeffHFpositivedirectionReconoiseDIF1;
20867 
20868  //========================================================================================== 5
20869  //======================================================================
20870  //======================================================================1D plot: R vs phi , different eta, depth=2
20871  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
20872  c3x5->Clear();
20874  c3x5->Divide(3, 5);
20875  c3x5->cd(1);
20876  int kcountHFpositivedirectionReconoiseDIF2 = 1;
20877  TH1F *h2CeffHFpositivedirectionReconoiseDIF2 = new TH1F("h2CeffHFpositivedirectionReconoiseDIF2", "", nphi, 0., 72.);
20878  for (int jeta = 0; jeta < njeta; jeta++) {
20879  // positivedirectionReconoiseDIF:
20880  if (jeta - 41 >= 28 && jeta - 41 <= 40) {
20881  // for (int i=0;i<ndepth;i++) {
20882  // depth=2
20883  for (int i = 1; i < 2; i++) {
20884  TH1F *HFpositivedirectionReconoiseDIF2 = (TH1F *)h2CeffHFpositivedirectionReconoiseDIF2->Clone("twod1");
20885  float ccctest = 0; // to avoid empty massive elements
20886  for (int jphi = 0; jphi < nphi; jphi++) {
20887  double ccc1 = breconoiseHF[i][jeta][jphi];
20888  if (ccc1 != 0.) {
20889  HFpositivedirectionReconoiseDIF2->Fill(jphi, ccc1);
20890  ccctest = 1.; //HFpositivedirectionReconoiseDIF2->SetBinError(i,0.01);
20891  }
20892  } // for jphi
20893  if (ccctest > 0.) {
20894  //cout<<"555 kcountHFpositivedirectionReconoiseDIF2 = "<<kcountHFpositivedirectionReconoiseDIF2 <<" jeta-41= "<< jeta-41 <<endl;
20895  c3x5->cd(kcountHFpositivedirectionReconoiseDIF2);
20896  HFpositivedirectionReconoiseDIF2->SetMarkerStyle(20);
20897  HFpositivedirectionReconoiseDIF2->SetMarkerSize(0.4);
20898  HFpositivedirectionReconoiseDIF2->GetYaxis()->SetLabelSize(0.04);
20899  HFpositivedirectionReconoiseDIF2->SetXTitle("HFpositivedirectionReconoiseDIF2 \b");
20900  HFpositivedirectionReconoiseDIF2->SetMarkerColor(2);
20901  HFpositivedirectionReconoiseDIF2->SetLineColor(0);
20902  gPad->SetGridy();
20903  gPad->SetGridx();
20904  // gPad->SetLogy();
20905  if (kcountHFpositivedirectionReconoiseDIF2 == 1)
20906  HFpositivedirectionReconoiseDIF2->SetXTitle("DIF for HF+ jeta = 28; depth = 2 \b");
20907  if (kcountHFpositivedirectionReconoiseDIF2 == 2)
20908  HFpositivedirectionReconoiseDIF2->SetXTitle("DIF for HF+ jeta = 29; depth = 2 \b");
20909  if (kcountHFpositivedirectionReconoiseDIF2 == 3)
20910  HFpositivedirectionReconoiseDIF2->SetXTitle("DIF for HF+ jeta = 30; depth = 2 \b");
20911  if (kcountHFpositivedirectionReconoiseDIF2 == 4)
20912  HFpositivedirectionReconoiseDIF2->SetXTitle("DIF for HF+ jeta = 31; depth = 2 \b");
20913  if (kcountHFpositivedirectionReconoiseDIF2 == 5)
20914  HFpositivedirectionReconoiseDIF2->SetXTitle("DIF for HF+ jeta = 32; depth = 2 \b");
20915  if (kcountHFpositivedirectionReconoiseDIF2 == 6)
20916  HFpositivedirectionReconoiseDIF2->SetXTitle("DIF for HF+ jeta = 33; depth = 2 \b");
20917  if (kcountHFpositivedirectionReconoiseDIF2 == 7)
20918  HFpositivedirectionReconoiseDIF2->SetXTitle("DIF for HF+ jeta = 34; depth = 2 \b");
20919  if (kcountHFpositivedirectionReconoiseDIF2 == 8)
20920  HFpositivedirectionReconoiseDIF2->SetXTitle("DIF for HF+ jeta = 35; depth = 2 \b");
20921  if (kcountHFpositivedirectionReconoiseDIF2 == 9)
20922  HFpositivedirectionReconoiseDIF2->SetXTitle("DIF for HF+ jeta = 36; depth = 2 \b");
20923  if (kcountHFpositivedirectionReconoiseDIF2 == 10)
20924  HFpositivedirectionReconoiseDIF2->SetXTitle("DIF for HF+ jeta = 37; depth = 2 \b");
20925  if (kcountHFpositivedirectionReconoiseDIF2 == 11)
20926  HFpositivedirectionReconoiseDIF2->SetXTitle("DIF for HF+ jeta = 38; depth = 2 \b");
20927  if (kcountHFpositivedirectionReconoiseDIF2 == 12)
20928  HFpositivedirectionReconoiseDIF2->SetXTitle("DIF for HF+ jeta = 39; depth = 2 \b");
20929  if (kcountHFpositivedirectionReconoiseDIF2 == 13)
20930  HFpositivedirectionReconoiseDIF2->SetXTitle("DIF for HF+ jeta = 40; depth = 2 \b");
20931  HFpositivedirectionReconoiseDIF2->Draw("Error");
20932  kcountHFpositivedirectionReconoiseDIF2++;
20933  if (kcountHFpositivedirectionReconoiseDIF2 > 13)
20934  break; // 4x6 = 24
20935  } //ccctest>0
20936 
20937  } // for i
20938  } //if(jeta-41 >= 28 && jeta-41 <= 40)
20939  } //for jeta
20941  c3x5->Update();
20942  c3x5->Print("DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth2HF.png");
20943  c3x5->Clear();
20944  // clean-up
20945  if (h2CeffHFpositivedirectionReconoiseDIF2)
20946  delete h2CeffHFpositivedirectionReconoiseDIF2;
20947 
20948  //========================================================================================== 1111114
20949  //======================================================================
20950  //======================================================================1D plot: DIF vs phi , different eta, depth=1
20951  //cout<<" 1D plot: DIF vs phi , different eta, depth=1 *****" <<endl;
20952  c3x5->Clear();
20954  c3x5->Divide(3, 5);
20955  c3x5->cd(1);
20956  int kcountHFnegativedirectionReconoiseDIF1 = 1;
20957  TH1F *h2CeffHFnegativedirectionReconoiseDIF1 = new TH1F("h2CeffHFnegativedirectionReconoiseDIF1", "", nphi, 0., 72.);
20958  for (int jeta = 0; jeta < njeta; jeta++) {
20959  // negativedirectionReconoiseDIF:
20960  if (jeta - 41 >= -41 && jeta - 41 <= -29) {
20961  // for (int i=0;i<ndepth;i++) {
20962  // depth=1
20963  for (int i = 0; i < 1; i++) {
20964  TH1F *HFnegativedirectionReconoiseDIF1 = (TH1F *)h2CeffHFnegativedirectionReconoiseDIF1->Clone("twod1");
20965  float ccctest = 0; // to avoid empty massive elements
20966  for (int jphi = 0; jphi < nphi; jphi++) {
20967  double ccc1 = breconoiseHF[i][jeta][jphi];
20968  if (ccc1 != 0.) {
20969  HFnegativedirectionReconoiseDIF1->Fill(jphi, ccc1);
20970  ccctest = 1.; //HFnegativedirectionReconoiseDIF1->SetBinError(i,0.01);
20971  }
20972  } // for jphi
20973  if (ccctest > 0.) {
20974  // cout<<"444 kcountHFnegativedirectionReconoiseDIF1 = "<<kcountHFnegativedirectionReconoiseDIF1 <<" jeta-41= "<< jeta-41 <<endl;
20975  c3x5->cd(kcountHFnegativedirectionReconoiseDIF1);
20976  HFnegativedirectionReconoiseDIF1->SetMarkerStyle(20);
20977  HFnegativedirectionReconoiseDIF1->SetMarkerSize(0.4);
20978  HFnegativedirectionReconoiseDIF1->GetYaxis()->SetLabelSize(0.04);
20979  HFnegativedirectionReconoiseDIF1->SetXTitle("HFnegativedirectionReconoiseDIF1 \b");
20980  HFnegativedirectionReconoiseDIF1->SetMarkerColor(2);
20981  HFnegativedirectionReconoiseDIF1->SetLineColor(0);
20982  gPad->SetGridy();
20983  gPad->SetGridx();
20984  // gPad->SetLogy();
20985  if (kcountHFnegativedirectionReconoiseDIF1 == 1)
20986  HFnegativedirectionReconoiseDIF1->SetXTitle("DIF for HF- jeta =-41; depth = 1 \b");
20987  if (kcountHFnegativedirectionReconoiseDIF1 == 2)
20988  HFnegativedirectionReconoiseDIF1->SetXTitle("DIF for HF- jeta =-40; depth = 1 \b");
20989  if (kcountHFnegativedirectionReconoiseDIF1 == 3)
20990  HFnegativedirectionReconoiseDIF1->SetXTitle("DIF for HF- jeta =-39; depth = 1 \b");
20991  if (kcountHFnegativedirectionReconoiseDIF1 == 4)
20992  HFnegativedirectionReconoiseDIF1->SetXTitle("DIF for HF- jeta =-38; depth = 1 \b");
20993  if (kcountHFnegativedirectionReconoiseDIF1 == 5)
20994  HFnegativedirectionReconoiseDIF1->SetXTitle("DIF for HF- jeta =-37; depth = 1 \b");
20995  if (kcountHFnegativedirectionReconoiseDIF1 == 6)
20996  HFnegativedirectionReconoiseDIF1->SetXTitle("DIF for HF- jeta =-36; depth = 1 \b");
20997  if (kcountHFnegativedirectionReconoiseDIF1 == 7)
20998  HFnegativedirectionReconoiseDIF1->SetXTitle("DIF for HF- jeta =-35; depth = 1 \b");
20999  if (kcountHFnegativedirectionReconoiseDIF1 == 8)
21000  HFnegativedirectionReconoiseDIF1->SetXTitle("DIF for HF- jeta =-34; depth = 1 \b");
21001  if (kcountHFnegativedirectionReconoiseDIF1 == 9)
21002  HFnegativedirectionReconoiseDIF1->SetXTitle("DIF for HF- jeta =-33; depth = 1 \b");
21003  if (kcountHFnegativedirectionReconoiseDIF1 == 10)
21004  HFnegativedirectionReconoiseDIF1->SetXTitle("DIF for HF- jeta =-32; depth = 1 \b");
21005  if (kcountHFnegativedirectionReconoiseDIF1 == 11)
21006  HFnegativedirectionReconoiseDIF1->SetXTitle("DIF for HF- jeta =-31; depth = 1 \b");
21007  if (kcountHFnegativedirectionReconoiseDIF1 == 12)
21008  HFnegativedirectionReconoiseDIF1->SetXTitle("DIF for HF- jeta =-30; depth = 1 \b");
21009  if (kcountHFnegativedirectionReconoiseDIF1 == 13)
21010  HFnegativedirectionReconoiseDIF1->SetXTitle("DIF for HF- jeta =-29; depth = 1 \b");
21011  HFnegativedirectionReconoiseDIF1->Draw("Error");
21012  kcountHFnegativedirectionReconoiseDIF1++;
21013  if (kcountHFnegativedirectionReconoiseDIF1 > 13)
21014  break; //
21015  } //ccctest>0
21016 
21017  } // for i
21018  } //if(jeta-41 >= -41 && jeta-41 <= -29)
21019  } //for jeta
21021  c3x5->Update();
21022  c3x5->Print("DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth1HF.png");
21023  c3x5->Clear();
21024  // clean-up
21025  if (h2CeffHFnegativedirectionReconoiseDIF1)
21026  delete h2CeffHFnegativedirectionReconoiseDIF1;
21027 
21028  //========================================================================================== 1111115
21029  //======================================================================
21030  //======================================================================1D plot: R vs phi , different eta, depth=2
21031  // cout<<" 1D plot: R vs phi , different eta, depth=2 *****" <<endl;
21032  c3x5->Clear();
21034  c3x5->Divide(3, 5);
21035  c3x5->cd(1);
21036  int kcountHFnegativedirectionReconoiseDIF2 = 1;
21037  TH1F *h2CeffHFnegativedirectionReconoiseDIF2 = new TH1F("h2CeffHFnegativedirectionReconoiseDIF2", "", nphi, 0., 72.);
21038  for (int jeta = 0; jeta < njeta; jeta++) {
21039  // negativedirectionReconoiseDIF:
21040  if (jeta - 41 >= -41 && jeta - 41 <= -29) {
21041  // for (int i=0;i<ndepth;i++) {
21042  // depth=2
21043  for (int i = 1; i < 2; i++) {
21044  TH1F *HFnegativedirectionReconoiseDIF2 = (TH1F *)h2CeffHFnegativedirectionReconoiseDIF2->Clone("twod1");
21045  float ccctest = 0; // to avoid empty massive elements
21046  for (int jphi = 0; jphi < nphi; jphi++) {
21047  double ccc1 = breconoiseHF[i][jeta][jphi];
21048  if (ccc1 != 0.) {
21049  HFnegativedirectionReconoiseDIF2->Fill(jphi, ccc1);
21050  ccctest = 1.; //HFnegativedirectionReconoiseDIF2->SetBinError(i,0.01);
21051  }
21052  } // for jphi
21053  if (ccctest > 0.) {
21054  //cout<<"555 kcountHFnegativedirectionReconoiseDIF2 = "<<kcountHFnegativedirectionReconoiseDIF2 <<" jeta-41= "<< jeta-41 <<endl;
21055  c3x5->cd(kcountHFnegativedirectionReconoiseDIF2);
21056  HFnegativedirectionReconoiseDIF2->SetMarkerStyle(20);
21057  HFnegativedirectionReconoiseDIF2->SetMarkerSize(0.4);
21058  HFnegativedirectionReconoiseDIF2->GetYaxis()->SetLabelSize(0.04);
21059  HFnegativedirectionReconoiseDIF2->SetXTitle("HFnegativedirectionReconoiseDIF2 \b");
21060  HFnegativedirectionReconoiseDIF2->SetMarkerColor(2);
21061  HFnegativedirectionReconoiseDIF2->SetLineColor(0);
21062  gPad->SetGridy();
21063  gPad->SetGridx();
21064  // gPad->SetLogy();
21065  if (kcountHFnegativedirectionReconoiseDIF2 == 1)
21066  HFnegativedirectionReconoiseDIF2->SetXTitle("DIF for HF- jeta =-41; depth = 2 \b");
21067  if (kcountHFnegativedirectionReconoiseDIF2 == 2)
21068  HFnegativedirectionReconoiseDIF2->SetXTitle("DIF for HF- jeta =-40; depth = 2 \b");
21069  if (kcountHFnegativedirectionReconoiseDIF2 == 3)
21070  HFnegativedirectionReconoiseDIF2->SetXTitle("DIF for HF- jeta =-39; depth = 2 \b");
21071  if (kcountHFnegativedirectionReconoiseDIF2 == 4)
21072  HFnegativedirectionReconoiseDIF2->SetXTitle("DIF for HF- jeta =-38; depth = 2 \b");
21073  if (kcountHFnegativedirectionReconoiseDIF2 == 5)
21074  HFnegativedirectionReconoiseDIF2->SetXTitle("DIF for HF- jeta =-37; depth = 2 \b");
21075  if (kcountHFnegativedirectionReconoiseDIF2 == 6)
21076  HFnegativedirectionReconoiseDIF2->SetXTitle("DIF for HF- jeta =-36; depth = 2 \b");
21077  if (kcountHFnegativedirectionReconoiseDIF2 == 7)
21078  HFnegativedirectionReconoiseDIF2->SetXTitle("DIF for HF- jeta =-35; depth = 2 \b");
21079  if (kcountHFnegativedirectionReconoiseDIF2 == 8)
21080  HFnegativedirectionReconoiseDIF2->SetXTitle("DIF for HF- jeta =-34; depth = 2 \b");
21081  if (kcountHFnegativedirectionReconoiseDIF2 == 9)
21082  HFnegativedirectionReconoiseDIF2->SetXTitle("DIF for HF- jeta =-33; depth = 2 \b");
21083  if (kcountHFnegativedirectionReconoiseDIF2 == 10)
21084  HFnegativedirectionReconoiseDIF2->SetXTitle("DIF for HF- jeta =-32; depth = 2 \b");
21085  if (kcountHFnegativedirectionReconoiseDIF2 == 11)
21086  HFnegativedirectionReconoiseDIF2->SetXTitle("DIF for HF- jeta =-31; depth = 2 \b");
21087  if (kcountHFnegativedirectionReconoiseDIF2 == 12)
21088  HFnegativedirectionReconoiseDIF2->SetXTitle("DIF for HF- jeta =-30; depth = 2 \b");
21089  if (kcountHFnegativedirectionReconoiseDIF2 == 13)
21090  HFnegativedirectionReconoiseDIF2->SetXTitle("DIF for HF- jeta =-20; depth = 2 \b");
21091  HFnegativedirectionReconoiseDIF2->Draw("Error");
21092  kcountHFnegativedirectionReconoiseDIF2++;
21093  if (kcountHFnegativedirectionReconoiseDIF2 > 13)
21094  break; // 4x6 = 24
21095  } //ccctest>0
21096 
21097  } // for i
21098  } //if(jeta-41 >= -41 && jeta-41 <= -29)
21099  } //for jeta
21101  c3x5->Update();
21102  c3x5->Print("DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth2HF.png");
21103  c3x5->Clear();
21104  // clean-up
21105  if (h2CeffHFnegativedirectionReconoiseDIF2)
21106  delete h2CeffHFnegativedirectionReconoiseDIF2;
21107 
21108  //======================================================================================================================
21109  //======================================================================================================================
21110  //======================================================================================================================
21111  //======================================================================================================================
21112  //======================================================================================================================
21113  //======================================================================================================================
21114  //======================================================================================================================
21115  // DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD:
21116 
21117  //cout<<" Start Vaiance: preparation *****" <<endl;
21118  TH2F *reconoiseVariance1HF1 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy2_HF1");
21119  TH2F *reconoiseVariance0HF1 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HF1");
21120  TH2F *reconoiseVarianceHF1 = (TH2F *)reconoiseVariance1HF1->Clone("reconoiseVarianceHF1");
21121  reconoiseVarianceHF1->Divide(reconoiseVariance1HF1, reconoiseVariance0HF1, 1, 1, "B");
21122  TH2F *reconoiseVariance1HF2 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy2_HF2");
21123  TH2F *reconoiseVariance0HF2 = (TH2F *)dir->FindObjectAny("h_recNoiseEnergy0_HF2");
21124  TH2F *reconoiseVarianceHF2 = (TH2F *)reconoiseVariance1HF2->Clone("reconoiseVarianceHF2");
21125  reconoiseVarianceHF2->Divide(reconoiseVariance1HF2, reconoiseVariance0HF2, 1, 1, "B");
21126  //cout<<" Vaiance: preparation DONE *****" <<endl;
21127  //====================================================================== put Vaiance=Dispersia = Sig**2=<R**2> - (<R>)**2 into massive reconoisevarianceHF
21128  // = sum(R*R)/N - (sum(R)/N)**2
21129  for (int jeta = 0; jeta < njeta; jeta++) {
21130  if ((jeta - 41 >= -41 && jeta - 41 <= -29) || (jeta - 41 >= 28 && jeta - 41 <= 40)) {
21131  //preparation for PHI normalization:
21132  double sumreconoiseHF0 = 0;
21133  int nsumreconoiseHF0 = 0;
21134  double sumreconoiseHF1 = 0;
21135  int nsumreconoiseHF1 = 0;
21136  for (int jphi = 0; jphi < njphi; jphi++) {
21137  reconoisevarianceHF[0][jeta][jphi] = reconoiseVarianceHF1->GetBinContent(jeta + 1, jphi + 1);
21138  reconoisevarianceHF[1][jeta][jphi] = reconoiseVarianceHF2->GetBinContent(jeta + 1, jphi + 1);
21139  sumreconoiseHF0 += reconoisevarianceHF[0][jeta][jphi];
21140  ++nsumreconoiseHF0;
21141  sumreconoiseHF1 += reconoisevarianceHF[1][jeta][jphi];
21142  ++nsumreconoiseHF1;
21143  } // phi
21144  // PHI normalization :
21145  for (int jphi = 0; jphi < njphi; jphi++) {
21146  if (reconoisevarianceHF[0][jeta][jphi] != 0.)
21147  reconoisevarianceHF[0][jeta][jphi] /= (sumreconoiseHF0 / nsumreconoiseHF0);
21148  if (reconoisevarianceHF[1][jeta][jphi] != 0.)
21149  reconoisevarianceHF[1][jeta][jphi] /= (sumreconoiseHF1 / nsumreconoiseHF1);
21150  } // phi
21151  // reconoisevarianceHF (D) = sum(R*R)/N - (sum(R)/N)**2
21152  for (int jphi = 0; jphi < njphi; jphi++) {
21153  // cout<<"12 12 12 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
21154  reconoisevarianceHF[0][jeta][jphi] -= areconoiseHF[0][jeta][jphi] * areconoiseHF[0][jeta][jphi];
21155  reconoisevarianceHF[0][jeta][jphi] = fabs(reconoisevarianceHF[0][jeta][jphi]);
21156  reconoisevarianceHF[1][jeta][jphi] -= areconoiseHF[1][jeta][jphi] * areconoiseHF[1][jeta][jphi];
21157  reconoisevarianceHF[1][jeta][jphi] = fabs(reconoisevarianceHF[1][jeta][jphi]);
21158  }
21159  }
21160  }
21161  //cout<<" Vaiance: DONE*****" <<endl;
21162  //------------------------ 2D-eta/phi-plot: D, averaged over depthfs
21163  //======================================================================
21164  //======================================================================
21165  //cout<<" R2D-eta/phi-plot: D, averaged over depthfs *****" <<endl;
21166  c1x1->Clear();
21168  c1x0->Divide(1, 1);
21169  c1x0->cd(1);
21170  TH2F *DefzDreconoiseHF42D = new TH2F("DefzDreconoiseHF42D", "", neta, -41., 41., nphi, 0., 72.);
21171  TH2F *DefzDreconoiseHF42D0 = new TH2F("DefzDreconoiseHF42D0", "", neta, -41., 41., nphi, 0., 72.);
21172  TH2F *DefzDreconoiseHF42DF = (TH2F *)DefzDreconoiseHF42D0->Clone("DefzDreconoiseHF42DF");
21173  for (int i = 0; i < ndepth; i++) {
21174  for (int jeta = 0; jeta < neta; jeta++) {
21175  if ((jeta - 41 >= -41 && jeta - 41 <= -29) || (jeta - 41 >= 28 && jeta - 41 <= 40)) {
21176  for (int jphi = 0; jphi < nphi; jphi++) {
21177  double ccc1 = reconoisevarianceHF[i][jeta][jphi];
21178  int k2plot = jeta - 41;
21179  int kkk = k2plot; //if(k2plot >0 kkk=k2plot+1; //-41 +41 !=0
21180  if (areconoiseHF[i][jeta][jphi] > 0.) {
21181  DefzDreconoiseHF42D->Fill(kkk, jphi, ccc1);
21182  DefzDreconoiseHF42D0->Fill(kkk, jphi, 1.);
21183  }
21184  }
21185  }
21186  }
21187  }
21188  DefzDreconoiseHF42DF->Divide(DefzDreconoiseHF42D, DefzDreconoiseHF42D0, 1, 1, "B"); // average A
21189  // DefzDreconoiseHF1->Sumw2();
21190  gPad->SetGridy();
21191  gPad->SetGridx(); // gPad->SetLogz();
21192  DefzDreconoiseHF42DF->SetMarkerStyle(20);
21193  DefzDreconoiseHF42DF->SetMarkerSize(0.4);
21194  DefzDreconoiseHF42DF->GetZaxis()->SetLabelSize(0.08);
21195  DefzDreconoiseHF42DF->SetXTitle("<D>_depth #eta \b");
21196  DefzDreconoiseHF42DF->SetYTitle(" #phi \b");
21197  DefzDreconoiseHF42DF->SetZTitle("<D>_depth \b");
21198  DefzDreconoiseHF42DF->SetMarkerColor(2);
21199  DefzDreconoiseHF42DF->SetLineColor(
21200  0); // DefzDreconoiseHF42DF->SetMaximum(1.000); // DefzDreconoiseHF42DF->SetMinimum(1.0);
21201  DefzDreconoiseHF42DF->Draw("COLZ");
21203  c1x0->Update();
21204  c1x0->Print("DreconoiseGeneralD2PhiSymmetryHF.png");
21205  c1x0->Clear();
21206  // clean-up
21207  if (DefzDreconoiseHF42D)
21208  delete DefzDreconoiseHF42D;
21209  if (DefzDreconoiseHF42D0)
21210  delete DefzDreconoiseHF42D0;
21211  if (DefzDreconoiseHF42DF)
21212  delete DefzDreconoiseHF42DF;
21213  //====================================================================== 1D plot: D vs phi , averaged over depthfs & eta
21214  //======================================================================
21215  //cout<<" 1D plot: D vs phi , averaged over depthfs & eta *****" <<endl;
21216  c1x1->Clear();
21218  c1x1->Divide(1, 1);
21219  c1x1->cd(1);
21220  TH1F *DefzDreconoiseHF41D = new TH1F("DefzDreconoiseHF41D", "", nphi, 0., 72.);
21221  TH1F *DefzDreconoiseHF41D0 = new TH1F("DefzDreconoiseHF41D0", "", nphi, 0., 72.);
21222  TH1F *DefzDreconoiseHF41DF = (TH1F *)DefzDreconoiseHF41D0->Clone("DefzDreconoiseHF41DF");
21223 
21224  for (int jphi = 0; jphi < nphi; jphi++) {
21225  for (int jeta = 0; jeta < neta; jeta++) {
21226  if ((jeta - 41 >= -41 && jeta - 41 <= -29) || (jeta - 41 >= 28 && jeta - 41 <= 40)) {
21227  for (int i = 0; i < ndepth; i++) {
21228  double ccc1 = reconoisevarianceHF[i][jeta][jphi];
21229  if (areconoiseHF[i][jeta][jphi] > 0.) {
21230  DefzDreconoiseHF41D->Fill(jphi, ccc1);
21231  DefzDreconoiseHF41D0->Fill(jphi, 1.);
21232  }
21233  }
21234  }
21235  }
21236  }
21237  // DefzDreconoiseHF41D->Sumw2();DefzDreconoiseHF41D0->Sumw2();
21238 
21239  DefzDreconoiseHF41DF->Divide(DefzDreconoiseHF41D, DefzDreconoiseHF41D0, 1, 1, "B"); // R averaged over depthfs & eta
21240  DefzDreconoiseHF41D0->Sumw2();
21241  // for (int jphi=1;jphi<73;jphi++) {DefzDreconoiseHF41DF->SetBinError(jphi,0.01);}
21242  gPad->SetGridy();
21243  gPad->SetGridx(); // gPad->SetLogz();
21244  DefzDreconoiseHF41DF->SetMarkerStyle(20);
21245  DefzDreconoiseHF41DF->SetMarkerSize(1.4);
21246  DefzDreconoiseHF41DF->GetZaxis()->SetLabelSize(0.08);
21247  DefzDreconoiseHF41DF->SetXTitle("#phi \b");
21248  DefzDreconoiseHF41DF->SetYTitle(" <D> \b");
21249  DefzDreconoiseHF41DF->SetZTitle("<D>_PHI - AllDepthfs \b");
21250  DefzDreconoiseHF41DF->SetMarkerColor(4);
21251  DefzDreconoiseHF41DF->SetLineColor(
21252  4); // DefzDreconoiseHF41DF->SetMinimum(0.8); DefzDreconoiseHF41DF->SetMinimum(-0.015);
21253  DefzDreconoiseHF41DF->Draw("Error");
21255  c1x1->Update();
21256  c1x1->Print("DreconoiseGeneralD1PhiSymmetryHF.png");
21257  c1x1->Clear();
21258  // clean-up
21259  if (DefzDreconoiseHF41D)
21260  delete DefzDreconoiseHF41D;
21261  if (DefzDreconoiseHF41D0)
21262  delete DefzDreconoiseHF41D0;
21263  if (DefzDreconoiseHF41DF)
21264  delete DefzDreconoiseHF41DF;
21265  //========================================================================================== 14
21266  //======================================================================
21267  //======================================================================1D plot: D vs phi , different eta, depth=1
21268  //cout<<" 1D plot: D vs phi , different eta, depth=1 *****" <<endl;
21269  c3x5->Clear();
21271  c3x5->Divide(3, 5);
21272  c3x5->cd(1);
21273  int kcountHFpositivedirectionReconoiseD1 = 1;
21274  TH1F *h2CeffHFpositivedirectionReconoiseD1 = new TH1F("h2CeffHFpositivedirectionReconoiseD1", "", nphi, 0., 72.);
21275 
21276  for (int jeta = 0; jeta < njeta; jeta++) {
21277  // positivedirectionReconoiseD:
21278  if (jeta - 41 >= 28 && jeta - 41 <= 40) {
21279  // for (int i=0;i<ndepth;i++) {
21280  // depth=1
21281  for (int i = 0; i < 1; i++) {
21282  TH1F *HFpositivedirectionReconoiseD1 = (TH1F *)h2CeffHFpositivedirectionReconoiseD1->Clone("twod1");
21283 
21284  float ccctest = 0; // to avoid empty massive elements
21285  for (int jphi = 0; jphi < nphi; jphi++) {
21286  double ccc1 = reconoisevarianceHF[i][jeta][jphi];
21287  if (areconoiseHF[i][jeta][jphi] > 0.) {
21288  HFpositivedirectionReconoiseD1->Fill(jphi, ccc1);
21289  ccctest = 1.; //HFpositivedirectionReconoiseD1->SetBinError(i,0.01);
21290  }
21291  } // for jphi
21292  if (ccctest > 0.) {
21293  //cout<<"1414 kcountHFpositivedirectionReconoiseD1 = "<<kcountHFpositivedirectionReconoiseD1 <<" jeta-41= "<< jeta-41 <<endl;
21294  c3x5->cd(kcountHFpositivedirectionReconoiseD1);
21295  HFpositivedirectionReconoiseD1->SetMarkerStyle(20);
21296  HFpositivedirectionReconoiseD1->SetMarkerSize(0.4);
21297  HFpositivedirectionReconoiseD1->GetYaxis()->SetLabelSize(0.04);
21298  HFpositivedirectionReconoiseD1->SetXTitle("HFpositivedirectionReconoiseD1 \b");
21299  HFpositivedirectionReconoiseD1->SetMarkerColor(2);
21300  HFpositivedirectionReconoiseD1->SetLineColor(0);
21301  gPad->SetGridy();
21302  gPad->SetGridx();
21303  // gPad->SetLogy();
21304  if (kcountHFpositivedirectionReconoiseD1 == 1)
21305  HFpositivedirectionReconoiseD1->SetXTitle("D for HF+ jeta = 28; depth = 1 \b");
21306  if (kcountHFpositivedirectionReconoiseD1 == 2)
21307  HFpositivedirectionReconoiseD1->SetXTitle("D for HF+ jeta = 29; depth = 1 \b");
21308  if (kcountHFpositivedirectionReconoiseD1 == 3)
21309  HFpositivedirectionReconoiseD1->SetXTitle("D for HF+ jeta = 30; depth = 1 \b");
21310  if (kcountHFpositivedirectionReconoiseD1 == 4)
21311  HFpositivedirectionReconoiseD1->SetXTitle("D for HF+ jeta = 31; depth = 1 \b");
21312  if (kcountHFpositivedirectionReconoiseD1 == 5)
21313  HFpositivedirectionReconoiseD1->SetXTitle("D for HF+ jeta = 32; depth = 1 \b");
21314  if (kcountHFpositivedirectionReconoiseD1 == 6)
21315  HFpositivedirectionReconoiseD1->SetXTitle("D for HF+ jeta = 33; depth = 1 \b");
21316  if (kcountHFpositivedirectionReconoiseD1 == 7)
21317  HFpositivedirectionReconoiseD1->SetXTitle("D for HF+ jeta = 34; depth = 1 \b");
21318  if (kcountHFpositivedirectionReconoiseD1 == 8)
21319  HFpositivedirectionReconoiseD1->SetXTitle("D for HF+ jeta = 35; depth = 1 \b");
21320  if (kcountHFpositivedirectionReconoiseD1 == 9)
21321  HFpositivedirectionReconoiseD1->SetXTitle("D for HF+ jeta = 36; depth = 1 \b");
21322  if (kcountHFpositivedirectionReconoiseD1 == 10)
21323  HFpositivedirectionReconoiseD1->SetXTitle("D for HF+ jeta = 37; depth = 1 \b");
21324  if (kcountHFpositivedirectionReconoiseD1 == 11)
21325  HFpositivedirectionReconoiseD1->SetXTitle("D for HF+ jeta = 38; depth = 1 \b");
21326  if (kcountHFpositivedirectionReconoiseD1 == 12)
21327  HFpositivedirectionReconoiseD1->SetXTitle("D for HF+ jeta = 39; depth = 1 \b");
21328  if (kcountHFpositivedirectionReconoiseD1 == 13)
21329  HFpositivedirectionReconoiseD1->SetXTitle("D for HF+ jeta = 40; depth = 1 \b");
21330  HFpositivedirectionReconoiseD1->Draw("Error");
21331  kcountHFpositivedirectionReconoiseD1++;
21332  if (kcountHFpositivedirectionReconoiseD1 > 13)
21333  break; // 4x6 = 24
21334  } //ccctest>0
21335 
21336  } // for i
21337  } //if(jeta-41 >= 28 && jeta-41 <= 40)
21338  } //for jeta
21340  c3x5->Update();
21341  c3x5->Print("DreconoisePositiveDirectionhistD1PhiSymmetryDepth1HF.png");
21342  c3x5->Clear();
21343  // clean-up
21344  if (h2CeffHFpositivedirectionReconoiseD1)
21345  delete h2CeffHFpositivedirectionReconoiseD1;
21346  //========================================================================================== 15
21347  //======================================================================
21348  //======================================================================1D plot: D vs phi , different eta, depth=2
21349  //cout<<" 1D plot: D vs phi , different eta, depth=2 *****" <<endl;
21350  c3x5->Clear();
21351  c3x5->Divide(3, 5);
21352  c3x5->cd(1);
21353  int kcountHFpositivedirectionReconoiseD2 = 1;
21354  TH1F *h2CeffHFpositivedirectionReconoiseD2 = new TH1F("h2CeffHFpositivedirectionReconoiseD2", "", nphi, 0., 72.);
21355 
21356  for (int jeta = 0; jeta < njeta; jeta++) {
21357  // positivedirectionReconoiseD:
21358  if (jeta - 41 >= 28 && jeta - 41 <= 40) {
21359  // for (int i=0;i<ndepth;i++) {
21360  // depth=2
21361  for (int i = 1; i < 2; i++) {
21362  TH1F *HFpositivedirectionReconoiseD2 = (TH1F *)h2CeffHFpositivedirectionReconoiseD2->Clone("twod1");
21363 
21364  float ccctest = 0; // to avoid empty massive elements
21365  for (int jphi = 0; jphi < nphi; jphi++) {
21366  double ccc1 = reconoisevarianceHF[i][jeta][jphi];
21367  if (areconoiseHF[i][jeta][jphi] > 0.) {
21368  HFpositivedirectionReconoiseD2->Fill(jphi, ccc1);
21369  ccctest = 1.; //HFpositivedirectionReconoiseD2->SetBinError(i,0.01);
21370  }
21371  } // for jphi
21372  if (ccctest > 0.) {
21373  //cout<<"1515 kcountHFpositivedirectionReconoiseD2 = "<<kcountHFpositivedirectionReconoiseD2 <<" jeta-41= "<< jeta-41 <<endl;
21374  c3x5->cd(kcountHFpositivedirectionReconoiseD2);
21375  HFpositivedirectionReconoiseD2->SetMarkerStyle(20);
21376  HFpositivedirectionReconoiseD2->SetMarkerSize(0.4);
21377  HFpositivedirectionReconoiseD2->GetYaxis()->SetLabelSize(0.04);
21378  HFpositivedirectionReconoiseD2->SetXTitle("HFpositivedirectionReconoiseD2 \b");
21379  HFpositivedirectionReconoiseD2->SetMarkerColor(2);
21380  HFpositivedirectionReconoiseD2->SetLineColor(0);
21381  gPad->SetGridy();
21382  gPad->SetGridx();
21383  // gPad->SetLogy();
21384  if (kcountHFpositivedirectionReconoiseD2 == 1)
21385  HFpositivedirectionReconoiseD2->SetXTitle("D for HF+ jeta = 28; depth = 2 \b");
21386  if (kcountHFpositivedirectionReconoiseD2 == 2)
21387  HFpositivedirectionReconoiseD2->SetXTitle("D for HF+ jeta = 29; depth = 2 \b");
21388  if (kcountHFpositivedirectionReconoiseD2 == 3)
21389  HFpositivedirectionReconoiseD2->SetXTitle("D for HF+ jeta = 30; depth = 2 \b");
21390  if (kcountHFpositivedirectionReconoiseD2 == 4)
21391  HFpositivedirectionReconoiseD2->SetXTitle("D for HF+ jeta = 31; depth = 2 \b");
21392  if (kcountHFpositivedirectionReconoiseD2 == 5)
21393  HFpositivedirectionReconoiseD2->SetXTitle("D for HF+ jeta = 32; depth = 2 \b");
21394  if (kcountHFpositivedirectionReconoiseD2 == 6)
21395  HFpositivedirectionReconoiseD2->SetXTitle("D for HF+ jeta = 33; depth = 2 \b");
21396  if (kcountHFpositivedirectionReconoiseD2 == 7)
21397  HFpositivedirectionReconoiseD2->SetXTitle("D for HF+ jeta = 34; depth = 2 \b");
21398  if (kcountHFpositivedirectionReconoiseD2 == 8)
21399  HFpositivedirectionReconoiseD2->SetXTitle("D for HF+ jeta = 35; depth = 2 \b");
21400  if (kcountHFpositivedirectionReconoiseD2 == 9)
21401  HFpositivedirectionReconoiseD2->SetXTitle("D for HF+ jeta = 36; depth = 2 \b");
21402  if (kcountHFpositivedirectionReconoiseD2 == 10)
21403  HFpositivedirectionReconoiseD2->SetXTitle("D for HF+ jeta = 37; depth = 2 \b");
21404  if (kcountHFpositivedirectionReconoiseD2 == 11)
21405  HFpositivedirectionReconoiseD2->SetXTitle("D for HF+ jeta = 38; depth = 2 \b");
21406  if (kcountHFpositivedirectionReconoiseD2 == 12)
21407  HFpositivedirectionReconoiseD2->SetXTitle("D for HF+ jeta = 39; depth = 2 \b");
21408  if (kcountHFpositivedirectionReconoiseD2 == 13)
21409  HFpositivedirectionReconoiseD2->SetXTitle("D for HF+ jeta = 40; depth = 2 \b");
21410  HFpositivedirectionReconoiseD2->Draw("Error");
21411  kcountHFpositivedirectionReconoiseD2++;
21412  if (kcountHFpositivedirectionReconoiseD2 > 13)
21413  break; // 4x6 = 24
21414  } //ccctest>0
21415 
21416  } // for i
21417  } //if(jeta-41 >= 28 && jeta-41 <= 40)
21418  } //for jeta
21420  c3x5->Update();
21421  c3x5->Print("DreconoisePositiveDirectionhistD1PhiSymmetryDepth2HF.png");
21422  c3x5->Clear();
21423  // clean-up
21424  if (h2CeffHFpositivedirectionReconoiseD2)
21425  delete h2CeffHFpositivedirectionReconoiseD2;
21426  //========================================================================================== 22222214
21427  //======================================================================
21428  //======================================================================1D plot: D vs phi , different eta, depth=1
21429  //cout<<" 1D plot: D vs phi , different eta, depth=1 *****" <<endl;
21430  c3x5->Clear();
21432  c3x5->Divide(3, 5);
21433  c3x5->cd(1);
21434  int kcountHFnegativedirectionReconoiseD1 = 1;
21435  TH1F *h2CeffHFnegativedirectionReconoiseD1 = new TH1F("h2CeffHFnegativedirectionReconoiseD1", "", nphi, 0., 72.);
21436 
21437  for (int jeta = 0; jeta < njeta; jeta++) {
21438  // negativedirectionReconoiseD:
21439  if (jeta - 41 >= -41 && jeta - 41 <= -29) {
21440  // for (int i=0;i<ndepth;i++) {
21441  // depth=1
21442  for (int i = 0; i < 1; i++) {
21443  TH1F *HFnegativedirectionReconoiseD1 = (TH1F *)h2CeffHFnegativedirectionReconoiseD1->Clone("twod1");
21444 
21445  float ccctest = 0; // to avoid empty massive elements
21446  for (int jphi = 0; jphi < nphi; jphi++) {
21447  double ccc1 = reconoisevarianceHF[i][jeta][jphi];
21448  if (areconoiseHF[i][jeta][jphi] > 0.) {
21449  HFnegativedirectionReconoiseD1->Fill(jphi, ccc1);
21450  ccctest = 1.; //HFnegativedirectionReconoiseD1->SetBinError(i,0.01);
21451  }
21452  } // for jphi
21453  if (ccctest > 0.) {
21454  //cout<<"1414 kcountHFnegativedirectionReconoiseD1 = "<<kcountHFnegativedirectionReconoiseD1 <<" jeta-41= "<< jeta-41 <<endl;
21455  c3x5->cd(kcountHFnegativedirectionReconoiseD1);
21456  HFnegativedirectionReconoiseD1->SetMarkerStyle(20);
21457  HFnegativedirectionReconoiseD1->SetMarkerSize(0.4);
21458  HFnegativedirectionReconoiseD1->GetYaxis()->SetLabelSize(0.04);
21459  HFnegativedirectionReconoiseD1->SetXTitle("HFnegativedirectionReconoiseD1 \b");
21460  HFnegativedirectionReconoiseD1->SetMarkerColor(2);
21461  HFnegativedirectionReconoiseD1->SetLineColor(0);
21462  gPad->SetGridy();
21463  gPad->SetGridx();
21464  // gPad->SetLogy();
21465  if (kcountHFnegativedirectionReconoiseD1 == 1)
21466  HFnegativedirectionReconoiseD1->SetXTitle("D for HF- jeta =-41; depth = 1 \b");
21467  if (kcountHFnegativedirectionReconoiseD1 == 2)
21468  HFnegativedirectionReconoiseD1->SetXTitle("D for HF- jeta =-40; depth = 1 \b");
21469  if (kcountHFnegativedirectionReconoiseD1 == 3)
21470  HFnegativedirectionReconoiseD1->SetXTitle("D for HF- jeta =-39; depth = 1 \b");
21471  if (kcountHFnegativedirectionReconoiseD1 == 4)
21472  HFnegativedirectionReconoiseD1->SetXTitle("D for HF- jeta =-38; depth = 1 \b");
21473  if (kcountHFnegativedirectionReconoiseD1 == 5)
21474  HFnegativedirectionReconoiseD1->SetXTitle("D for HF- jeta =-37; depth = 1 \b");
21475  if (kcountHFnegativedirectionReconoiseD1 == 6)
21476  HFnegativedirectionReconoiseD1->SetXTitle("D for HF- jeta =-36; depth = 1 \b");
21477  if (kcountHFnegativedirectionReconoiseD1 == 7)
21478  HFnegativedirectionReconoiseD1->SetXTitle("D for HF- jeta =-35; depth = 1 \b");
21479  if (kcountHFnegativedirectionReconoiseD1 == 8)
21480  HFnegativedirectionReconoiseD1->SetXTitle("D for HF- jeta =-34; depth = 1 \b");
21481  if (kcountHFnegativedirectionReconoiseD1 == 9)
21482  HFnegativedirectionReconoiseD1->SetXTitle("D for HF- jeta =-33; depth = 1 \b");
21483  if (kcountHFnegativedirectionReconoiseD1 == 10)
21484  HFnegativedirectionReconoiseD1->SetXTitle("D for HF- jeta =-32; depth = 1 \b");
21485  if (kcountHFnegativedirectionReconoiseD1 == 11)
21486  HFnegativedirectionReconoiseD1->SetXTitle("D for HF- jeta =-31; depth = 1 \b");
21487  if (kcountHFnegativedirectionReconoiseD1 == 12)
21488  HFnegativedirectionReconoiseD1->SetXTitle("D for HF- jeta =-30; depth = 1 \b");
21489  if (kcountHFnegativedirectionReconoiseD1 == 13)
21490  HFnegativedirectionReconoiseD1->SetXTitle("D for HF- jeta =-29; depth = 1 \b");
21491  HFnegativedirectionReconoiseD1->Draw("Error");
21492  kcountHFnegativedirectionReconoiseD1++;
21493  if (kcountHFnegativedirectionReconoiseD1 > 13)
21494  break; // 4x6 = 24
21495  } //ccctest>0
21496 
21497  } // for i
21498  } //if(jeta-41 >= -41 && jeta-41 <= -29)
21499  } //for jeta
21501  c3x5->Update();
21502  c3x5->Print("DreconoiseNegativeDirectionhistD1PhiSymmetryDepth1HF.png");
21503  c3x5->Clear();
21504  // clean-up
21505  if (h2CeffHFnegativedirectionReconoiseD1)
21506  delete h2CeffHFnegativedirectionReconoiseD1;
21507  //========================================================================================== 22222215
21508  //======================================================================
21509  //======================================================================1D plot: D vs phi , different eta, depth=2
21510  //cout<<" 1D plot: D vs phi , different eta, depth=2 *****" <<endl;
21511  c3x5->Clear();
21512  c3x5->Divide(3, 5);
21513  c3x5->cd(1);
21514  int kcountHFnegativedirectionReconoiseD2 = 1;
21515  TH1F *h2CeffHFnegativedirectionReconoiseD2 = new TH1F("h2CeffHFnegativedirectionReconoiseD2", "", nphi, 0., 72.);
21516 
21517  for (int jeta = 0; jeta < njeta; jeta++) {
21518  // negativedirectionReconoiseD:
21519  if (jeta - 41 >= -41 && jeta - 41 <= -29) {
21520  // for (int i=0;i<ndepth;i++) {
21521  // depth=2
21522  for (int i = 1; i < 2; i++) {
21523  TH1F *HFnegativedirectionReconoiseD2 = (TH1F *)h2CeffHFnegativedirectionReconoiseD2->Clone("twod1");
21524 
21525  float ccctest = 0; // to avoid empty massive elements
21526  for (int jphi = 0; jphi < nphi; jphi++) {
21527  double ccc1 = reconoisevarianceHF[i][jeta][jphi];
21528  if (areconoiseHF[i][jeta][jphi] > 0.) {
21529  HFnegativedirectionReconoiseD2->Fill(jphi, ccc1);
21530  ccctest = 1.; //HFnegativedirectionReconoiseD2->SetBinError(i,0.01);
21531  }
21532  } // for jphi
21533  if (ccctest > 0.) {
21534  //cout<<"1515 kcountHFnegativedirectionReconoiseD2 = "<<kcountHFnegativedirectionReconoiseD2 <<" jeta-41= "<< jeta-41 <<endl;
21535  c3x5->cd(kcountHFnegativedirectionReconoiseD2);
21536  HFnegativedirectionReconoiseD2->SetMarkerStyle(20);
21537  HFnegativedirectionReconoiseD2->SetMarkerSize(0.4);
21538  HFnegativedirectionReconoiseD2->GetYaxis()->SetLabelSize(0.04);
21539  HFnegativedirectionReconoiseD2->SetXTitle("HFnegativedirectionReconoiseD2 \b");
21540  HFnegativedirectionReconoiseD2->SetMarkerColor(2);
21541  HFnegativedirectionReconoiseD2->SetLineColor(0);
21542  gPad->SetGridy();
21543  gPad->SetGridx();
21544  // gPad->SetLogy();
21545  if (kcountHFnegativedirectionReconoiseD2 == 1)
21546  HFnegativedirectionReconoiseD2->SetXTitle("D for HF- jeta =-41; depth = 2 \b");
21547  if (kcountHFnegativedirectionReconoiseD2 == 2)
21548  HFnegativedirectionReconoiseD2->SetXTitle("D for HF- jeta =-40; depth = 2 \b");
21549  if (kcountHFnegativedirectionReconoiseD2 == 3)
21550  HFnegativedirectionReconoiseD2->SetXTitle("D for HF- jeta =-39; depth = 2 \b");
21551  if (kcountHFnegativedirectionReconoiseD2 == 4)
21552  HFnegativedirectionReconoiseD2->SetXTitle("D for HF- jeta =-38; depth = 2 \b");
21553  if (kcountHFnegativedirectionReconoiseD2 == 5)
21554  HFnegativedirectionReconoiseD2->SetXTitle("D for HF- jeta =-37; depth = 2 \b");
21555  if (kcountHFnegativedirectionReconoiseD2 == 6)
21556  HFnegativedirectionReconoiseD2->SetXTitle("D for HF- jeta =-36; depth = 2 \b");
21557  if (kcountHFnegativedirectionReconoiseD2 == 7)
21558  HFnegativedirectionReconoiseD2->SetXTitle("D for HF- jeta =-35; depth = 2 \b");
21559  if (kcountHFnegativedirectionReconoiseD2 == 8)
21560  HFnegativedirectionReconoiseD2->SetXTitle("D for HF- jeta =-34; depth = 2 \b");
21561  if (kcountHFnegativedirectionReconoiseD2 == 9)
21562  HFnegativedirectionReconoiseD2->SetXTitle("D for HF- jeta =-33; depth = 2 \b");
21563  if (kcountHFnegativedirectionReconoiseD2 == 10)
21564  HFnegativedirectionReconoiseD2->SetXTitle("D for HF- jeta =-32; depth = 2 \b");
21565  if (kcountHFnegativedirectionReconoiseD2 == 11)
21566  HFnegativedirectionReconoiseD2->SetXTitle("D for HF- jeta =-31; depth = 2 \b");
21567  if (kcountHFnegativedirectionReconoiseD2 == 12)
21568  HFnegativedirectionReconoiseD2->SetXTitle("D for HF- jeta =-30; depth = 2 \b");
21569  if (kcountHFnegativedirectionReconoiseD2 == 13)
21570  HFnegativedirectionReconoiseD2->SetXTitle("D for HF- jeta =-29; depth = 2 \b");
21571  HFnegativedirectionReconoiseD2->Draw("Error");
21572  kcountHFnegativedirectionReconoiseD2++;
21573  if (kcountHFnegativedirectionReconoiseD2 > 13)
21574  break; // 4x6 = 24
21575  } //ccctest>0
21576 
21577  } // for i
21578  } //if(jeta-41 >= -41 && jeta-41 <= -29)
21579  } //for jeta
21581  c3x5->Update();
21582  c3x5->Print("DreconoiseNegativeDirectionhistD1PhiSymmetryDepth2HF.png");
21583  c3x5->Clear();
21584  // clean-up
21585  if (h2CeffHFnegativedirectionReconoiseD2)
21586  delete h2CeffHFnegativedirectionReconoiseD2;
21587 
21588  //===================================================================== END of Reconoise HF for phi-symmetry
21589  //===================================================================== END of Reconoise HF for phi-symmetry
21590  //===================================================================== END of Reconoise HF for phi-symmetry
21591  //============================================================================================================ END of Reconoise for phi-symmetry
21592  //============================================================================================================ END of Reconoise for phi-symmetry
21593  //============================================================================================================ END of Reconoise for phi-symmetry
21594 
21595  //==================================================================================================================================================== END for phi-symmetry
21596  //==================================================================================================================================================== END for phi-symmetry
21597  //==================================================================================================================================================== END for phi-symmetry
21598  //====================================================================================================================================================
21599 
21600  std::cout << " We are here to print 2017 MAPs " << std::endl;
21601  //======================================================================
21602 
21603  //======================================================================
21605 
21606  TH2F *Map_ALL = new TH2F("Map_All", "Map_all", 82, -41, 40, 72, 0, 71);
21607  int nx = Map_ALL->GetXaxis()->GetNbins();
21608  int ny = Map_ALL->GetYaxis()->GetNbins();
21609  int NBad = 0;
21610  int NWarn = 0;
21611  int NCalib = 0;
21612  int NPed = 0;
21613  // int Eta[3][10000]={0};
21614  int Eta[4][10000] = {0};
21615  int Phi[4][10000] = {0};
21616  int Sub[4][10000] = {0};
21617  int Depth[4][10000] = {0};
21618  string Comment[4][10000] = {""};
21619  string Text[33] = {"", "Cm", "Am", "Wm", "Rm", "TNm", "TXm", "", "", "", "", "Cc", "Ac", "Wc", "Rc", "TNc", "TXc",
21620  "", "", "", "", "GS", "", "", "", "", "", "", "", "", "", "Pm", "pWm"};
21621  int flag_W = 0;
21622  int flag_B = 0;
21623  int flag_P = 0;
21624 
21625  for (int i = 1; i <= nx; i++) { //Eta
21626  for (int j = 1; j <= ny; j++) { // Phi
21627  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
21628  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
21629  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
21630  // int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
21631  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
21632  if (Map_SUB[sub][k]->GetBinContent(i, j) != 0) {
21633  Map_SUB[sub][k]->SetBinContent(i, j, 0.5);
21634  Map_ALL->SetBinContent(i, j, 0.5);
21635  }
21636  }
21637  }
21638  }
21639  }
21640 
21641  for (int i = 1; i <= nx; i++) { //Eta
21642  for (int j = 1; j <= ny; j++) { // Phi
21643  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
21644  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
21645  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
21646  // int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
21647  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
21648  flag_W = 0;
21649  flag_B = 0;
21650  flag_P = 0;
21651  for (int test = 1; test <= 6; test++) { //Test: 1-Wm, 2-Rm, etc
21652  //Bad
21653  if (Map_Ampl[test][sub][k]->GetBinContent(i, j) >
21654  0.1) { //Rate 0.1 for displaying on whole detector map and subdetector map
21655  Map_ALL->SetBinContent(i, j, 1.);
21656  Map_SUB[sub][k]->SetBinContent(i, j, 1.);
21657  if (flag_B == 0) {
21658  NBad += 1;
21659  Eta[2][NBad] = i - 41;
21660  Phi[2][NBad] = j - 1;
21661  Sub[2][NBad] = sub;
21662  Depth[2][NBad] = k;
21663  Comment[2][NBad] = Text[test];
21664  } else
21665  Comment[2][NBad] += ", " + Text[test];
21666  flag_B = 1;
21667  // cout<<"Map_Ampl["<<test<<"]["<<sub<<"]["<<k<<"]->GetBinContent("<<i<<","<<j<<")= "<<Map_Ampl[test][sub][k]->GetBinContent(i,j)<<endl;
21668  }
21669  //Warning
21670  /*
21671  if ((Map_Ampl[test][sub][k]->GetBinContent(i,j) != 0.)&&(Map_Ampl[test][sub][k]->GetBinContent(i,j) < 0.001) ) {
21672  if (Map_SUB[sub][k]->GetBinContent(i,j)!=1.) Map_SUB[sub][k]->SetBinContent(i,j,0.75);
21673  if (Map_ALL->GetBinContent(i,j)!=1.) Map_ALL->SetBinContent(i,j,0.75);
21674  if (flag_W == 0) {
21675  NWarn +=1;
21676  Eta[1][NWarn]=i-41;
21677  Phi[1][NWarn]=j-1;
21678  Sub[1][NWarn]=sub;
21679  Depth[1][NWarn]=k;
21680  Comment[1][NWarn]=Text[test];
21681  }
21682  else Comment[1][NWarn]+=", "+Text[test];
21683  flag_W = 1;
21684 // cout<<"Map_Ampl["<<test<<"]["<<sub<<"]["<<k<<"]->GetBinContent("<<i<<","<<j<<")= "<<Map_Ampl[test][sub][k]->GetBinContent(i,j)<<endl;
21685  }
21686 */
21687 
21688  } //end test
21689 
21690  //Calib
21691  /*
21692  for (int test=11;test<=16;test++) { //Test: 1-2.E, 2-2.F, etc
21693  if (Map_Ampl[test][sub][k]->GetBinContent(i,j) != 0.) {
21694 // if (Map_SUB[sub][k]->GetBinContent(i,j)!=1.0) Map_SUB[sub][k]->SetBinContent(i,j,0.3);
21695 // if (Map_ALL->GetBinContent(i,j)!=1.) Map_ALL->SetBinContent(i,j,0.3);
21696  if (flag_W == 0) {
21697  NWarn +=1;
21698  Eta[1][NWarn]=i-41;
21699  Phi[1][NWarn]=j-1;
21700  Sub[1][NWarn]=sub;
21701  Depth[1][NWarn]=k;
21702  Comment[1][NWarn]=Text[test];
21703  }
21704  else Comment[1][NWarn]+=", "+Text[test];
21705  flag_W = 1;
21706 // cout<<"Map_Ampl["<<test<<"]["<<sub<<"]["<<k<<"]->GetBinContent("<<i<<","<<j<<")= "<<Map_Ampl[test][sub][k]->GetBinContent(i,j)<<endl;
21707  }
21708  } //end test
21709 */
21710  //Gain stabil
21711  for (int test = 21; test <= 21; test++) {
21712  if (abs(Map_Ampl[test][sub][k]->GetBinContent(i, j)) > porog[sub]) {
21713  if (Map_SUB[sub][k]->GetBinContent(i, j) != 1.0)
21714  Map_SUB[sub][k]->SetBinContent(i, j, 0.75);
21715  if (Map_ALL->GetBinContent(i, j) != 1.) {
21716  Map_ALL->SetBinContent(i, j, 0.75);
21717  if (flag_W == 0) {
21718  NWarn += 1;
21719  Eta[1][NWarn] = i - 41;
21720  Phi[1][NWarn] = j - 1;
21721  Sub[1][NWarn] = sub;
21722  Depth[1][NWarn] = k;
21723  Comment[1][NWarn] = Text[test];
21724  } else
21725  Comment[1][NWarn] += ", " + Text[test];
21726  flag_W = 1;
21727 
21728  cout << "Map_Ampl[" << test << "][" << sub << "][" << k << "]->GetBinContent(" << i << "," << j
21729  << ")= " << Map_Ampl[test][sub][k]->GetBinContent(i, j) << endl;
21730  }
21731  }
21732  } //end test
21733 
21734  //Pedestals
21735  for (int test = 31; test <= 32; test++) {
21736  if (Map_Ampl[test][sub][k]->GetBinContent(i, j) > 0.1) {
21737  // if (Map_SUB[sub][k]->GetBinContent(i,j)!=1.0) Map_SUB[sub][k]->SetBinContent(i,j,0.75);
21738  // if (Map_ALL->GetBinContent(i,j)!=1.) Map_ALL->SetBinContent(i,j,0.75);
21739  if (flag_P == 0) {
21740  NPed += 1;
21741  Eta[3][NPed] = i - 41;
21742  Phi[3][NPed] = j - 1;
21743  Sub[3][NPed] = sub;
21744  Depth[3][NPed] = k;
21745  Comment[3][NPed] = Text[test];
21746  } else
21747  Comment[3][NPed] += ", " + Text[test];
21748  flag_P = 1;
21749 
21750  // cout<<"Map_Ampl["<<test<<"]["<<sub<<"]["<<k<<"]->GetBinContent("<<i<<","<<j<<")= "<<Map_Ampl[test][sub][k]->GetBinContent(i,j)<<endl;
21751  }
21752  } //end test
21753 
21754  } //end Depth
21755  } //end Sub
21756  } //end Phi
21757  } //end Eta
21758  // subdet maps
21759  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
21760 
21761  std::cout << " 2017 MAPS_SUB " << sub << std::endl;
21762  // if (sub==1) cHB->Divide(2,1);
21763  if (sub == 1)
21764  cHB->Divide(2, 2);
21765  // if (sub==2) cHE->Divide(3,1);
21766  if (sub == 2)
21767  cHE->Divide(3, 3);
21768  if (sub == 3)
21769  cONE->Divide(1, 1);
21770  // if (sub==4) cHB->Divide(2,1);
21771  if (sub == 4)
21772  cHF->Divide(2, 2);
21773  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
21774  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
21775  // int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
21776  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
21777  if (sub == 1)
21778  cHB->cd(k);
21779  if (sub == 2)
21780  cHE->cd(k);
21781  if (sub == 3)
21782  cONE->cd(k - 3);
21783  if (sub == 4)
21784  cHF->cd(k);
21785  gPad->SetGridy();
21786  gPad->SetGridx();
21787  // gPad->SetLogz();
21788  // gStyle->SetTitleOffset(0.5, "Y");
21789  if (sub == 1)
21790  sprintf(str, "HB, Depth%d \b", k);
21791  if (sub == 2)
21792  sprintf(str, "HE, Depth%d \b", k);
21793  if (sub == 3)
21794  sprintf(str, "HO, Depth%d \b", k);
21795  if (sub == 4)
21796  sprintf(str, "HF, Depth%d \b", k);
21797  Map_SUB[sub][k]->SetTitle(str);
21798  Map_SUB[sub][k]->SetXTitle("#eta \b");
21799  Map_SUB[sub][k]->SetYTitle("#phi \b");
21800  Map_SUB[sub][k]->Draw("COL");
21801  Map_SUB[sub][k]->GetYaxis()->SetRangeUser(0, 72.);
21802  Map_SUB[sub][k]->GetZaxis()->SetRangeUser(0., 1.);
21803  if (sub == 1) {
21804  cHB->Modified();
21805  cHB->Update();
21806  }
21807  if (sub == 2) {
21808  cHE->Modified();
21809  cHE->Update();
21810  }
21811  if (sub == 3) {
21812  cONE->Modified();
21813  cONE->Update();
21814  }
21815  if (sub == 4) {
21816  cHF->Modified();
21817  cHF->Update();
21818  }
21819  } //end depth
21820  if (sub == 1) {
21821  cHB->Print("MAPHB.png");
21822  cHB->Clear();
21823  }
21824  if (sub == 2) {
21825  cHE->Print("MAPHE.png");
21826  cHE->Clear();
21827  }
21828  if (sub == 3) {
21829  cONE->Print("MAPHO.png");
21830  cONE->Clear();
21831  }
21832  if (sub == 4) {
21833  cHF->Print("MAPHF.png");
21834  cHF->Clear();
21835  }
21836  }
21837 
21839  // TCanvas *cmain1 = new TCanvas("cmain1","MAP",200,10,1400,1800);
21840  TCanvas *cmain1 = new TCanvas("cmain1", "MAP", 250, 10, 1450, 1410);
21841  cmain1->Divide(2, 2);
21842 
21843  cmain1->cd(1);
21844  TH1F *JDBEYESJ0 = (TH1F *)dir->FindObjectAny("h_totalAmplitudeHBperEvent");
21845  JDBEYESJ0->SetStats(0);
21846  JDBEYESJ0->SetMarkerStyle(20);
21847  JDBEYESJ0->SetMarkerSize(0.8);
21848  JDBEYESJ0->GetYaxis()->SetLabelSize(0.04);
21849  JDBEYESJ0->SetXTitle("iEvent \b");
21850  JDBEYESJ0->SetYTitle("totalAmplitude perEvent \b");
21851  JDBEYESJ0->SetTitle("HB \b");
21852  JDBEYESJ0->SetMarkerColor(2);
21853  JDBEYESJ0->SetLineColor(1);
21854  JDBEYESJ0->SetMinimum(0.8);
21855  JDBEYESJ0->Draw("HIST same P0");
21856 
21857  cmain1->cd(2);
21858  TH1F *JDBEYESJ1 = (TH1F *)dir->FindObjectAny("h_totalAmplitudeHEperEvent");
21859  JDBEYESJ1->SetStats(0);
21860  JDBEYESJ1->SetMarkerStyle(20);
21861  JDBEYESJ1->SetMarkerSize(0.8);
21862  JDBEYESJ1->GetYaxis()->SetLabelSize(0.04);
21863  JDBEYESJ1->SetXTitle("iEvent \b");
21864  JDBEYESJ1->SetYTitle("totalAmplitude perEvent \b");
21865  JDBEYESJ1->SetTitle("HE \b");
21866  JDBEYESJ1->SetMarkerColor(2);
21867  JDBEYESJ1->SetLineColor(1);
21868  JDBEYESJ1->SetMinimum(0.8);
21869  JDBEYESJ1->Draw("HIST same P0");
21870 
21871  cmain1->cd(3);
21872  TH1F *JDBEYESJ2 = (TH1F *)dir->FindObjectAny("h_totalAmplitudeHFperEvent");
21873  JDBEYESJ2->SetStats(0);
21874  JDBEYESJ2->SetMarkerStyle(20);
21875  JDBEYESJ2->SetMarkerSize(0.8);
21876  JDBEYESJ2->GetYaxis()->SetLabelSize(0.04);
21877  JDBEYESJ2->SetXTitle("iEvent \b");
21878  JDBEYESJ2->SetYTitle("totalAmplitude perEvent \b");
21879  JDBEYESJ2->SetTitle("HF \b");
21880  JDBEYESJ2->SetMarkerColor(2);
21881  JDBEYESJ2->SetLineColor(1);
21882  JDBEYESJ2->SetMinimum(0.8);
21883  JDBEYESJ2->Draw("HIST same P0");
21884 
21885  cmain1->cd(4);
21886  TH1F *JDBEYESJ3 = (TH1F *)dir->FindObjectAny("h_totalAmplitudeHOperEvent");
21887  JDBEYESJ3->SetStats(0);
21888  JDBEYESJ3->SetMarkerStyle(20);
21889  JDBEYESJ3->SetMarkerSize(0.8);
21890  JDBEYESJ3->GetYaxis()->SetLabelSize(0.04);
21891  JDBEYESJ3->SetXTitle("iEvent \b");
21892  JDBEYESJ3->SetYTitle("totalAmplitude perEvent \b");
21893  JDBEYESJ3->SetTitle("HO \b");
21894  JDBEYESJ3->SetMarkerColor(2);
21895  JDBEYESJ3->SetLineColor(1);
21896  JDBEYESJ3->SetMinimum(0.8);
21897  JDBEYESJ3->Draw("HIST same P0");
21898 
21899  cmain1->Modified();
21900  cmain1->Update();
21901  cmain1->Print("EVENTDEPENDENCE.png");
21902 
21903  std::cout << " EVENTDEPENDENCE " << std::endl;
21904 
21906  // ALL SubDet
21907  gStyle->SetOptTitle(0);
21908  TCanvas *cmain = new TCanvas("cmain", "MAP", 1000, 1000);
21909  //cmain->cd(1);
21910  gPad->SetGridy();
21911  gPad->SetGridx();
21912  // gPad->SetLogz();
21913  Map_ALL->SetTitleOffset(1.3, "Y");
21914  Map_ALL->SetXTitle("#eta \b");
21915  Map_ALL->SetYTitle("#phi \b");
21916  Map_ALL->Draw("COL");
21917  Map_ALL->GetYaxis()->SetRangeUser(0, 72.);
21918  Map_ALL->GetZaxis()->SetRangeUser(0, 1.);
21919  cmain->Modified();
21920  cmain->Update();
21921  cmain->Print("MAP.png");
21922 
21923  std::cout << "******** MAP_ALL done" << std::endl;
21924  std::cout << "********" << std::endl;
21925 
21926  std::cout << "********" << std::endl;
21927  std::cout << "************ Start creating each test kind for each subdet html pages:" << std::endl;
21928 
21929  //======================================================================
21930 
21931  //======================================================================
21932  // Creating each test kind for each subdet html pages:
21933  std::string raw_class, raw_class1, raw_class2, raw_class3;
21934  int ind = 0;
21935 
21936  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
21937  ofstream htmlFileT, htmlFileC, htmlFileD, htmlFileP, htmlFileS, htmlFileM, htmlFileR, htmlFileN;
21938  if (sub == 1) {
21939  htmlFileT.open("HB_Tile.html");
21940  htmlFileC.open("HB_Calib.html");
21941  htmlFileD.open("HB_Drift.html");
21942  htmlFileP.open("HB_Pedestals.html");
21943  htmlFileS.open("HB_Shapes.html");
21944  htmlFileM.open("HB_PhiSymmetryDigi.html");
21945  htmlFileR.open("HB_PhiSymmetryRecoSignal.html");
21946  htmlFileN.open("HB_PhiSymmetryRecoNoise.html");
21947  }
21948  if (sub == 2) {
21949  htmlFileT.open("HE_Tile.html");
21950  htmlFileC.open("HE_Calib.html");
21951  htmlFileD.open("HE_Drift.html");
21952  htmlFileP.open("HE_Pedestals.html");
21953  htmlFileS.open("HE_Shapes.html");
21954  htmlFileM.open("HE_PhiSymmetryDigi.html");
21955  htmlFileR.open("HE_PhiSymmetryRecoSignal.html");
21956  htmlFileN.open("HE_PhiSymmetryRecoNoise.html");
21957  }
21958  if (sub == 3) {
21959  htmlFileT.open("HO_Tile.html");
21960  htmlFileC.open("HO_Calib.html");
21961  htmlFileD.open("HO_Drift.html");
21962  htmlFileP.open("HO_Pedestals.html");
21963  htmlFileS.open("HO_Shapes.html");
21964  }
21965  if (sub == 4) {
21966  htmlFileT.open("HF_Tile.html");
21967  htmlFileC.open("HF_Calib.html");
21968  htmlFileD.open("HF_Drift.html");
21969  htmlFileP.open("HF_Pedestals.html");
21970  htmlFileS.open("HF_Shapes.html");
21971  htmlFileM.open("HF_PhiSymmetryDigi.html");
21972  htmlFileR.open("HF_PhiSymmetryRecoSignal.html");
21973  htmlFileN.open("HF_PhiSymmetryRecoNoise.html");
21974  }
21975 
21976  // Megatile channels
21977  htmlFileT << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
21978  htmlFileT << "<head>" << std::endl;
21979  htmlFileT << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
21980  htmlFileT << "<title> Remote Monitoring Tool </title>" << std::endl;
21981  htmlFileT << "<style type=\"text/css\">" << std::endl;
21982  htmlFileT << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
21983  << std::endl;
21984  htmlFileT << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
21985  htmlFileT << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
21986  "text-align: center;}"
21987  << std::endl;
21988  htmlFileT << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
21989  htmlFileT << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
21990  htmlFileT << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
21991  htmlFileT << "</style>" << std::endl;
21992  htmlFileT << "<body>" << std::endl;
21993 
21994  if (sub == 1)
21995  htmlFileT << "<h1> Criteria for megatile channels for HB, RUN = " << runnumber << " </h1>" << std::endl;
21996  if (sub == 2)
21997  htmlFileT << "<h1> Criteria for megatile channels for HE, RUN = " << runnumber << " </h1>" << std::endl;
21998  if (sub == 3)
21999  htmlFileT << "<h1> Criteria for megatile channels for HO, RUN = " << runnumber << " </h1>" << std::endl;
22000  if (sub == 4)
22001  htmlFileT << "<h1> Criteria for megatile channels for HF, RUN = " << runnumber << " </h1>" << std::endl;
22002  htmlFileT << "<br>" << std::endl;
22003 
22004  // Test Entries
22005 
22006  htmlFileT << "<h2> 0. Entries for each channel.</h3>" << std::endl;
22007  htmlFileT << "<h3> 0.A. Entries in each channel for each depth.</h3>" << std::endl;
22008  htmlFileT << "<h4> Channel legend: color is rate of entries </h4>" << std::endl;
22009  if (sub == 1)
22010  htmlFileT << " <img src=\"MapRateEntryHB.png\" />" << std::endl;
22011  if (sub == 2)
22012  htmlFileT << " <img src=\"MapRateEntryHE.png\" />" << std::endl;
22013  if (sub == 3)
22014  htmlFileT << " <img src=\"MapRateEntryHO.png\" />" << std::endl;
22015  if (sub == 4)
22016  htmlFileT << " <img src=\"MapRateEntryHF.png\" />" << std::endl;
22017  htmlFileT << "<br>" << std::endl;
22018 
22019  // Test Cm
22020  htmlFileT << "<h2> 1. Cm criterion: CapID errors for each channel.</h3>" << std::endl;
22021  htmlFileT << "<h3> 1.A. Rate of CapId failures in each channel for each depth.</h3>" << std::endl;
22022  htmlFileT << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
22023  if (sub == 1)
22024  htmlFileT << " <img src=\"MapRateCapIDHB.png\" />" << std::endl;
22025  if (sub == 2)
22026  htmlFileT << " <img src=\"MapRateCapIDHE.png\" />" << std::endl;
22027  if (sub == 3)
22028  htmlFileT << " <img src=\"MapRateCapIDHO.png\" />" << std::endl;
22029  if (sub == 4)
22030  htmlFileT << " <img src=\"MapRateCapIDHF.png\" />" << std::endl;
22031  htmlFileT << "<br>" << std::endl;
22032 
22033  // Am
22034  htmlFileT << "<h2> 2. Am criterion: ADC amplitude collected over all TSs(Full Amplitude) for each channel. </h3>"
22035  << std::endl;
22036  htmlFileT << "<h3> 2.A. Full ADC amplitude distribution over all events, channels and depths.</h3>" << std::endl;
22037  htmlFileT << "<h4> Legend: Bins less " << MIN_M[2][sub] << " correpond to bad ADC amplitude </h4>" << std::endl;
22038  if (sub == 1)
22039  htmlFileT << " <img src=\"HistAmplHB.png\" />" << std::endl;
22040  if (sub == 2)
22041  htmlFileT << " <img src=\"HistAmplHE.png\" />" << std::endl;
22042  if (sub == 3)
22043  htmlFileT << " <img src=\"HistAmplHO.png\" />" << std::endl;
22044  if (sub == 4)
22045  htmlFileT << " <img src=\"HistAmplHF.png\" />" << std::endl;
22046  htmlFileT << "<br>" << std::endl;
22047  htmlFileT << "<h3> 2.B. Rate of bad ADC amplitude (<" << MIN_M[2][sub] << ") in each channel for each depth. </h3>"
22048  << std::endl;
22049  htmlFileT << "<h4> Channel legend: white - good, other colours - bad. </h4>" << std::endl;
22050  if (sub == 1)
22051  htmlFileT << " <img src=\"MapRateAmplHB.png\" />" << std::endl;
22052  if (sub == 2)
22053  htmlFileT << " <img src=\"MapRateAmplHE.png\" />" << std::endl;
22054  if (sub == 3)
22055  htmlFileT << " <img src=\"MapRateAmplHO.png\" />" << std::endl;
22056  if (sub == 4)
22057  htmlFileT << " <img src=\"MapRateAmplHF.png\" />" << std::endl;
22058  htmlFileT << "<br>" << std::endl;
22059 
22060  // Test Wm
22061  htmlFileT << "<h2> 3. Wm criterion: RMS (width) of ADC amplutude for each channel.</h3>" << std::endl;
22062  htmlFileT << "<h3> 3.A. RMS distribution over all events, channel and depth.</h3>" << std::endl;
22063  htmlFileT << "<h4> Legend: Bins less " << MIN_M[3][sub] << " and more " << MAX_M[3][sub]
22064  << " correpond to bad RMS </h4>" << std::endl;
22065  if (sub == 1)
22066  htmlFileT << " <img src=\"HistRMSHB.png\" />" << std::endl;
22067  if (sub == 2)
22068  htmlFileT << " <img src=\"HistRMSHE.png\" />" << std::endl;
22069  if (sub == 3)
22070  htmlFileT << " <img src=\"HistRMSHO.png\" />" << std::endl;
22071  if (sub == 4)
22072  htmlFileT << " <img src=\"HistRMSHF.png\" />" << std::endl;
22073  htmlFileT << "<br>" << std::endl;
22074  htmlFileT << "<h3> 3.B. Rate of bad RMS (<" << MIN_M[3][sub] << ",>" << MAX_M[3][sub]
22075  << ") in each channel for each depth.</h3>" << std::endl;
22076  htmlFileT << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
22077  if (sub == 1)
22078  htmlFileT << " <img src=\"MapRateRMSHB.png\" />" << std::endl;
22079  if (sub == 2)
22080  htmlFileT << " <img src=\"MapRateRMSHE.png\" />" << std::endl;
22081  if (sub == 3)
22082  htmlFileT << " <img src=\"MapRateRMSHO.png\" />" << std::endl;
22083  if (sub == 4)
22084  htmlFileT << " <img src=\"MapRateRMSHF.png\" />" << std::endl;
22085  htmlFileT << "<br>" << std::endl;
22086 
22087  // Rm
22088  htmlFileT << "<h2> 4. Rm criterion: Ratio ADC value sum over four near maximum (-2, -1, max, +1) TS to ADC value "
22089  "sum over all TS for each channel. </h3>"
22090  << std::endl;
22091  htmlFileT << "<h3> 4.A. Ratio distribution over all events, channels and depths.</h3>" << std::endl;
22092  htmlFileT << "<h4> Legend: Bins less " << MIN_M[4][sub] << " and more " << MAX_M[4][sub]
22093  << " correpond to bad ratio </h4>" << std::endl;
22094  if (sub == 1)
22095  htmlFileT << " <img src=\"Hist43TStoAllTSHB.png\" />" << std::endl;
22096  if (sub == 2)
22097  htmlFileT << " <img src=\"Hist43TStoAllTSHE.png\" />" << std::endl;
22098  if (sub == 3)
22099  htmlFileT << " <img src=\"Hist43TStoAllTSHO.png\" />" << std::endl;
22100  if (sub == 4)
22101  htmlFileT << " <img src=\"Hist43TStoAllTSHF.png\" />" << std::endl;
22102  htmlFileT << "<br>" << std::endl;
22103  htmlFileT << "<h3> 4.B. Rate of bad ratio (<" << MIN_M[4][sub] << ", >" << MAX_M[4][sub]
22104  << ") in each channel for each depth.</h3>" << std::endl;
22105  htmlFileT << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
22106  if (sub == 1)
22107  htmlFileT << " <img src=\"MapRate43TStoAllTSHB.png\" />" << std::endl;
22108  if (sub == 2)
22109  htmlFileT << " <img src=\"MapRate43TStoAllTSHE.png\" />" << std::endl;
22110  if (sub == 3)
22111  htmlFileT << " <img src=\"MapRate43TStoAllTSHO.png\" />" << std::endl;
22112  if (sub == 4)
22113  htmlFileT << " <img src=\"MapRate43TStoAllTSHF.png\" />" << std::endl;
22114  htmlFileT << "<br>" << std::endl;
22115 
22116  // TNm
22117  htmlFileT << "<h2> 5. TNm criterion: Mean TS position for each channel.</h3>" << std::endl;
22118  htmlFileT << "<h3> 5.A. TN position distribution over all events, channels and depths.</h3>" << std::endl;
22119  htmlFileT << "<h4> Legend: Bins less " << MIN_M[5][sub] << " and more " << MAX_M[5][sub]
22120  << " correpond to bad mean position </h4>" << std::endl;
22121  if (sub == 1)
22122  htmlFileT << " <img src=\"HistMeanPosHB.png\" />" << std::endl;
22123  if (sub == 2)
22124  htmlFileT << " <img src=\"HistMeanPosHE.png\" />" << std::endl;
22125  if (sub == 3)
22126  htmlFileT << " <img src=\"HistMeanPosHO.png\" />" << std::endl;
22127  if (sub == 4)
22128  htmlFileT << " <img src=\"HistMeanPosHF.png\" />" << std::endl;
22129  htmlFileT << "<br>" << std::endl;
22130  htmlFileT << "<h3> 5.B. Rate of bad TN position (<" << MIN_M[5][sub] << ", >" << MAX_M[5][sub]
22131  << ") in each channel for each depth. </h3>" << std::endl;
22132  htmlFileT << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
22133  if (sub == 1)
22134  htmlFileT << " <img src=\"MapRateMeanPosHB.png\" />" << std::endl;
22135  if (sub == 2)
22136  htmlFileT << " <img src=\"MapRateMeanPosHE.png\" />" << std::endl;
22137  if (sub == 3)
22138  htmlFileT << " <img src=\"MapRateMeanPosHO.png\" />" << std::endl;
22139  if (sub == 4)
22140  htmlFileT << " <img src=\"MapRateMeanPosHF.png\" />" << std::endl;
22141  htmlFileT << "<br>" << std::endl;
22142 
22143  // TXm
22144  htmlFileT << "<h2> 6.TXm criterion: Maximum TS position for each channel.</h3>" << std::endl;
22145  htmlFileT << "<h3> 6.A. TX position distribution over all events, channel and depth.</h3>" << std::endl;
22146  htmlFileT << "<h4> Legend: Bins less " << MIN_M[6][sub] << " and more " << MAX_M[6][sub]
22147  << " correpond to bad position </h4>" << std::endl;
22148  if (sub == 1)
22149  htmlFileT << " <img src=\"HistMaxPosHB.png\" />" << std::endl;
22150  if (sub == 2)
22151  htmlFileT << " <img src=\"HistMaxPosHE.png\" />" << std::endl;
22152  if (sub == 3)
22153  htmlFileT << " <img src=\"HistMaxPosHO.png\" />" << std::endl;
22154  if (sub == 4)
22155  htmlFileT << " <img src=\"HistMaxPosHF.png\" />" << std::endl;
22156  htmlFileT << "<br>" << std::endl;
22157  htmlFileT << "<h3> 6.B. Rate of bad TX position (<" << MIN_M[6][sub] << ", >" << MAX_M[6][sub]
22158  << ") in each channel for each depth. </h3>" << std::endl;
22159  htmlFileT << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
22160  if (sub == 1)
22161  htmlFileT << " <img src=\"MapRateMaxPosHB.png\" />" << std::endl;
22162  if (sub == 2)
22163  htmlFileT << " <img src=\"MapRateMaxPosHE.png\" />" << std::endl;
22164  if (sub == 3)
22165  htmlFileT << " <img src=\"MapRateMaxPosHO.png\" />" << std::endl;
22166  if (sub == 4)
22167  htmlFileT << " <img src=\"MapRateMaxPosHF.png\" />" << std::endl;
22168  htmlFileT << "<br>" << std::endl;
22169 
22170  htmlFileT << "</body> " << std::endl;
22171  htmlFileT << "</html> " << std::endl;
22172  htmlFileT.close();
22173 
22174  //Calibration channels
22175  htmlFileC << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
22176  htmlFileC << "<head>" << std::endl;
22177  htmlFileC << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
22178  htmlFileC << "<title> Raw Data Analyser </title>" << std::endl;
22179  htmlFileC << "<style type=\"text/css\">" << std::endl;
22180  htmlFileC << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
22181  << std::endl;
22182  htmlFileC << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
22183  htmlFileC << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
22184  "text-align: center;}"
22185  << std::endl;
22186  htmlFileC << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
22187  htmlFileC << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
22188  htmlFileC << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
22189  htmlFileC << "</style>" << std::endl;
22190  htmlFileC << "<body>" << std::endl;
22191 
22192  if (sub == 1)
22193  htmlFileC << "<h1> Criteria for calibration channels for HB, RUN = " << runnumber << " </h1>" << std::endl;
22194  if (sub == 2)
22195  htmlFileC << "<h1> Criteria for calibration channels for HE, RUN = " << runnumber << " </h1>" << std::endl;
22196  if (sub == 3)
22197  htmlFileC << "<h1> Criteria for calibration channels for HO, RUN = " << runnumber << " </h1>" << std::endl;
22198  if (sub == 4)
22199  htmlFileC << "<h1> Criteria for calibration channels for HF, RUN = " << runnumber << " </h1>" << std::endl;
22200  htmlFileC << "<br>" << std::endl;
22201 
22202  // Test Entries
22203 
22204  htmlFileC << "<h2> 0. Entries for each channel.</h3>" << std::endl;
22205  htmlFileC << "<h3> 0.A. Entries in each channel for each depth.</h3>" << std::endl;
22206  htmlFileC << "<h4> Channel legend: color is rate of entries </h4>" << std::endl;
22207  if (sub == 1)
22208  htmlFileC << " <img src=\"MapRateCalibEntryHB.png\" />" << std::endl;
22209  if (sub == 2)
22210  htmlFileC << " <img src=\"MapRateCalibEntryHE.png\" />" << std::endl;
22211  if (sub == 3)
22212  htmlFileC << " <img src=\"MapRateCalibEntryHO.png\" />" << std::endl;
22213  if (sub == 4)
22214  htmlFileC << " <img src=\"MapRateCalibEntryHF.png\" />" << std::endl;
22215  htmlFileC << "<br>" << std::endl;
22216 
22217  // Test Cc
22218  htmlFileC << "<h2> 1. Cc criterion: CapID errors for each channel.</h3>" << std::endl;
22219  htmlFileC << "<h3> 1.A. Rate of CapId failures in each channel for each depth.</h3>" << std::endl;
22220  htmlFileC << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
22221  if (sub == 1)
22222  htmlFileC << " <img src=\"MapRateCapCalibHB.png\" />" << std::endl;
22223  if (sub == 2)
22224  htmlFileC << " <img src=\"MapRateCapCalibHE.png\" />" << std::endl;
22225  if (sub == 3)
22226  htmlFileC << " <img src=\"MapRateCapCalibHO.png\" />" << std::endl;
22227  if (sub == 4)
22228  htmlFileC << " <img src=\"MapRateCapCalibHF.png\" />" << std::endl;
22229  htmlFileC << "<br>" << std::endl;
22230 
22231  // Ac
22232  htmlFileC << "<h2> 2. Ac criterion: ADC amplitude collected over all TSs(Full Amplitude) for each channel. </h3>"
22233  << std::endl;
22234  htmlFileC << "<h3> 2.A. Full ADC amplitude distribution over all events, channels and depths.</h3>" << std::endl;
22235  htmlFileC << "<h4> Legend: Bins less " << MIN_C[2][sub] << " correpond to bad ADC amplitude </h4>" << std::endl;
22236  if (sub == 1)
22237  htmlFileC << " <img src=\"HistAmplCalibHB.png\" />" << std::endl;
22238  if (sub == 2)
22239  htmlFileC << " <img src=\"HistAmplCalibHE.png\" />" << std::endl;
22240  if (sub == 3)
22241  htmlFileC << " <img src=\"HistAmplCalibHO.png\" />" << std::endl;
22242  if (sub == 4)
22243  htmlFileC << " <img src=\"HistAmplCalibHF.png\" />" << std::endl;
22244  htmlFileC << "<br>" << std::endl;
22245  htmlFileC << "<h3> 2.B. Rate of bad ADC amplitude (<" << MIN_C[2][sub] << ") in each channel for each depth. </h3>"
22246  << std::endl;
22247  htmlFileC << "<h4> Channel legend: white - good, other colours - bad. </h4>" << std::endl;
22248  if (sub == 1)
22249  htmlFileC << " <img src=\"MapRateAmplCalibHB.png\" />" << std::endl;
22250  if (sub == 2)
22251  htmlFileC << " <img src=\"MapRateAmplCalibHE.png\" />" << std::endl;
22252  if (sub == 3)
22253  htmlFileC << " <img src=\"MapRateAmplCalibHO.png\" />" << std::endl;
22254  if (sub == 4)
22255  htmlFileC << " <img src=\"MapRateAmplCalibHF.png\" />" << std::endl;
22256  htmlFileC << "<br>" << std::endl;
22257 
22258  // Test Wc
22259  htmlFileC << "<h2> 3. Wc criterion: RMS (width) of ADC amplutude for each channel.</h3>" << std::endl;
22260  htmlFileC << "<h3> 3.A. W distribution over all events, channel and depth.</h3>" << std::endl;
22261  htmlFileC << "<h4> Legend: Bins less " << MIN_C[3][sub] << " and more " << MAX_C[3][sub]
22262  << " correpond to bad RMS </h4>" << std::endl;
22263  if (sub == 1)
22264  htmlFileC << " <img src=\"HistRMSCalibHB.png\" />" << std::endl;
22265  if (sub == 2)
22266  htmlFileC << " <img src=\"HistRMSCalibHE.png\" />" << std::endl;
22267  if (sub == 3)
22268  htmlFileC << " <img src=\"HistRMSCalibHO.png\" />" << std::endl;
22269  if (sub == 4)
22270  htmlFileC << " <img src=\"HistRMSCalibHF.png\" />" << std::endl;
22271  htmlFileC << "<br>" << std::endl;
22272  htmlFileC << "<h3> 3.B. Rate of bad W (<" << MIN_C[3][sub] << ",>" << MAX_C[3][sub]
22273  << ") in each channel for each depth.</h3>" << std::endl;
22274  htmlFileC << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
22275  if (sub == 1)
22276  htmlFileC << " <img src=\"MapRateRMSCalibHB.png\" />" << std::endl;
22277  if (sub == 2)
22278  htmlFileC << " <img src=\"MapRateRMSCalibHE.png\" />" << std::endl;
22279  if (sub == 3)
22280  htmlFileC << " <img src=\"MapRateRMSCalibHO.png\" />" << std::endl;
22281  if (sub == 4)
22282  htmlFileC << " <img src=\"MapRateRMSCalibHF.png\" />" << std::endl;
22283  htmlFileC << "<br>" << std::endl;
22284 
22285  // Rc
22286  htmlFileC << "<h2> 4. Rc criterion: Ratio ADC value sum over five near maximum (-2, -1, max, +1, +2) TS to ADC "
22287  "value sum over all TS for each channel. </h3>"
22288  << std::endl;
22289  htmlFileC << "<h3> 4.A. Ratio distribution over all events, channels and depths.</h3>" << std::endl;
22290  htmlFileC << "<h4> Legend: Bins less " << MIN_C[4][sub] << " and more " << MAX_C[4][sub]
22291  << " correpond to bad ratio </h4>" << std::endl;
22292  if (sub == 1)
22293  htmlFileC << " <img src=\"Hist43TStoAllTSCalibHB.png\" />" << std::endl;
22294  if (sub == 2)
22295  htmlFileC << " <img src=\"Hist43TStoAllTSCalibHE.png\" />" << std::endl;
22296  if (sub == 3)
22297  htmlFileC << " <img src=\"Hist43TStoAllTSCalibHO.png\" />" << std::endl;
22298  if (sub == 4)
22299  htmlFileC << " <img src=\"Hist43TStoAllTSCalibHF.png\" />" << std::endl;
22300  htmlFileC << "<br>" << std::endl;
22301  htmlFileC << "<h3> 4.B. Rate of bad Ratio (<" << MIN_C[4][sub] << ", >" << MAX_C[4][sub]
22302  << ") in each channel for each depth.</h3>" << std::endl;
22303  htmlFileC << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
22304  if (sub == 1)
22305  htmlFileC << " <img src=\"MapRate43TStoAllTSCalibHB.png\" />" << std::endl;
22306  if (sub == 2)
22307  htmlFileC << " <img src=\"MapRate43TStoAllTSCalibHE.png\" />" << std::endl;
22308  if (sub == 3)
22309  htmlFileC << " <img src=\"MapRate43TStoAllTSCalibHO.png\" />" << std::endl;
22310  if (sub == 4)
22311  htmlFileC << " <img src=\"MapRate43TStoAllTSCalibHF.png\" />" << std::endl;
22312  htmlFileC << "<br>" << std::endl;
22313 
22314  // TNc
22315  htmlFileC << "<h2> 5. TNc criterion: Mean TS position for each channel.</h3>" << std::endl;
22316  htmlFileC << "<h3> 5.A. TN position distribution over all events, channels and depths.</h3>" << std::endl;
22317  htmlFileC << "<h4> Legend: Bins less " << MIN_C[5][sub] << " and more " << MAX_C[5][sub]
22318  << " correpond to bad position </h4>" << std::endl;
22319  if (sub == 1)
22320  htmlFileC << " <img src=\"HistMeanPosCalibHB.png\" />" << std::endl;
22321  if (sub == 2)
22322  htmlFileC << " <img src=\"HistMeanPosCalibHE.png\" />" << std::endl;
22323  if (sub == 3)
22324  htmlFileC << " <img src=\"HistMeanPosCalibHO.png\" />" << std::endl;
22325  if (sub == 4)
22326  htmlFileC << " <img src=\"HistMeanPosCalibHF.png\" />" << std::endl;
22327  htmlFileC << "<br>" << std::endl;
22328  htmlFileC << "<h3> 5.B. Rate of bad TN position (<" << MIN_C[5][sub] << ", >" << MAX_C[5][sub]
22329  << ") in each channel for each depth. </h3>" << std::endl;
22330  htmlFileC << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
22331  if (sub == 1)
22332  htmlFileC << " <img src=\"MapRateMeanPosCalibHB.png\" />" << std::endl;
22333  if (sub == 2)
22334  htmlFileC << " <img src=\"MapRateMeanPosCalibHE.png\" />" << std::endl;
22335  if (sub == 3)
22336  htmlFileC << " <img src=\"MapRateMeanPosCalibHO.png\" />" << std::endl;
22337  if (sub == 4)
22338  htmlFileC << " <img src=\"MapRateMeanPosCalibHF.png\" />" << std::endl;
22339  htmlFileC << "<br>" << std::endl;
22340 
22341  // TXm
22342  htmlFileC << "<h2> 6.TXc criterion: Maximum TS position for each channel.</h3>" << std::endl;
22343  htmlFileC << "<h3> 6.A. TX position distribution over all events, channel and depth.</h3>" << std::endl;
22344  htmlFileC << "<h4> Legend: Bins less " << MIN_C[6][sub] << " and more " << MAX_C[6][sub]
22345  << " correpond to bad position </h4>" << std::endl;
22346  if (sub == 1)
22347  htmlFileC << " <img src=\"HistMaxPosCalibHB.png\" />" << std::endl;
22348  if (sub == 2)
22349  htmlFileC << " <img src=\"HistMaxPosCalibHE.png\" />" << std::endl;
22350  if (sub == 3)
22351  htmlFileC << " <img src=\"HistMaxPosCalibHO.png\" />" << std::endl;
22352  if (sub == 4)
22353  htmlFileC << " <img src=\"HistMaxPosCalibHF.png\" />" << std::endl;
22354  htmlFileC << "<br>" << std::endl;
22355  htmlFileC << "<h3> 6.B. Rate of bad TX position (<" << MIN_C[6][sub] << ", >" << MAX_C[6][sub]
22356  << ") in each channel for each depth. </h3>" << std::endl;
22357  htmlFileC << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
22358  if (sub == 1)
22359  htmlFileC << " <img src=\"MapRateMaxPosCalibHB.png\" />" << std::endl;
22360  if (sub == 2)
22361  htmlFileC << " <img src=\"MapRateMaxPosCalibHE.png\" />" << std::endl;
22362  if (sub == 3)
22363  htmlFileC << " <img src=\"MapRateMaxPosCalibHO.png\" />" << std::endl;
22364  if (sub == 4)
22365  htmlFileC << " <img src=\"MapRateMaxPosCalibHF.png\" />" << std::endl;
22366  htmlFileC << "<br>" << std::endl;
22367 
22368  htmlFileC << "</body> " << std::endl;
22369  htmlFileC << "</html> " << std::endl;
22370  htmlFileC.close();
22371 
22372  //Response drift
22373  htmlFileD << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
22374  htmlFileD << "<head>" << std::endl;
22375  htmlFileD << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
22376  htmlFileD << "<title> Remore Monitoring Tool </title>" << std::endl;
22377  htmlFileD << "<style type=\"text/css\">" << std::endl;
22378  htmlFileD << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
22379  << std::endl;
22380  htmlFileD << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
22381  htmlFileD << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
22382  "text-align: center;}"
22383  << std::endl;
22384  htmlFileD << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
22385  htmlFileD << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
22386  htmlFileD << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
22387  htmlFileD << "</style>" << std::endl;
22388  htmlFileD << "<body>" << std::endl;
22389 
22390  if (sub == 1)
22391  htmlFileD << "<h1> Response drift for HB: Current RUN = " << runnumber << ", Reference RUN = " << refrunnumber
22392  << " </h1>" << std::endl;
22393  if (sub == 2)
22394  htmlFileD << "<h1> Response drift for HE: Current RUN = " << runnumber << ", Reference RUN = " << refrunnumber
22395  << " </h1>" << std::endl;
22396  if (sub == 3)
22397  htmlFileD << "<h1> Response drift for HO: Current RUN = " << runnumber << ", Reference RUN = " << refrunnumber
22398  << " </h1>" << std::endl;
22399  if (sub == 4)
22400  htmlFileD << "<h1> Response drift for HF: Current RUN = " << runnumber << ", Reference RUN = " << refrunnumber
22401  << " </h1>" << std::endl;
22402  htmlFileD << "<br>" << std::endl;
22403 
22404  // test GS
22405  htmlFileD << "<h2> 1. Gain Stability (GS) </h3>" << std::endl;
22406  htmlFileD << "<h3> 1.A. Averaged channel response, collected over all TS, for Current run in each channel for each "
22407  "depth.</h3>"
22408  << std::endl;
22409  htmlFileD << "<h4> Channel legend: colour means cooresponding value of mean response. </h4>" << std::endl;
22410  if (sub == 1)
22411  htmlFileD << " <img src=\"MapRateAmpl1HB.png\" />" << std::endl;
22412  if (sub == 2)
22413  htmlFileD << " <img src=\"MapRateAmpl1HE.png\" />" << std::endl;
22414  if (sub == 3)
22415  htmlFileD << " <img src=\"MapRateAmpl1HO.png\" />" << std::endl;
22416  if (sub == 4)
22417  htmlFileD << " <img src=\"MapRateAmpl1HF.png\" />" << std::endl;
22418  htmlFileD << "<br>" << std::endl;
22419  htmlFileD << "<h3> 1.B. Averaged channel response, collected over all TS, for Reference run in each channel for "
22420  "each depth.</h3>"
22421  << std::endl;
22422  htmlFileD << "<h4> Channel legend: colour means cooresponding value of mean response. </h4>" << std::endl;
22423  if (sub == 1)
22424  htmlFileD << " <img src=\"MapRateAmpl2HB.png\" />" << std::endl;
22425  if (sub == 2)
22426  htmlFileD << " <img src=\"MapRateAmpl2HE.png\" />" << std::endl;
22427  if (sub == 3)
22428  htmlFileD << " <img src=\"MapRateAmpl2HO.png\" />" << std::endl;
22429  if (sub == 4)
22430  htmlFileD << " <img src=\"MapRateAmpl2HF.png\" />" << std::endl;
22431  htmlFileD << "<br>" << std::endl;
22432  htmlFileD << "<h3> 1.C. Relative difference between Current and Reference run distribution over all events, "
22433  "channels for each depth.</h3>"
22434  << std::endl;
22435  htmlFileD << "<h4> Legend: Bins less -" << porog[sub] << "% and more +" << porog[sub]
22436  << "% correpond to bad relative difference position </h4>" << std::endl;
22437  if (sub == 1)
22438  htmlFileD << " <img src=\"HistAmplDriftDepthHB.png\" />" << std::endl;
22439  if (sub == 2)
22440  htmlFileD << " <img src=\"HistAmplDriftDepthHE.png\" />" << std::endl;
22441  if (sub == 3)
22442  htmlFileD << " <img src=\"HistAmplDriftDepthHO.png\" />" << std::endl;
22443  if (sub == 4)
22444  htmlFileD << " <img src=\"HistAmplDriftDepthHF.png\" />" << std::endl;
22445  htmlFileD << "<br>" << std::endl;
22446  htmlFileD << "<h3> 1.D. Rate of bad relative difference (<-" << porog[sub] << ", >+" << porog[sub]
22447  << ") in each channel for each depth.</h3>" << std::endl;
22448  htmlFileD << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
22449  if (sub == 1)
22450  htmlFileD << " <img src=\"MapRateAmplDriftHB.png\" />" << std::endl;
22451  if (sub == 2)
22452  htmlFileD << " <img src=\"MapRateAmplDriftHE.png\" />" << std::endl;
22453  if (sub == 3)
22454  htmlFileD << " <img src=\"MapRateAmplDriftHO.png\" />" << std::endl;
22455  if (sub == 4)
22456  htmlFileD << " <img src=\"MapRateAmplDriftHF.png\" />" << std::endl;
22457  htmlFileD << "<br>" << std::endl;
22458 
22459  htmlFileD << "</body> " << std::endl;
22460  htmlFileD << "</html> " << std::endl;
22461  htmlFileD.close();
22462 
22463  // Pedestals
22464  htmlFileP << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
22465  htmlFileP << "<head>" << std::endl;
22466  htmlFileP << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
22467  htmlFileP << "<title> Remote Monitoring Tool </title>" << std::endl;
22468  htmlFileP << "<style type=\"text/css\">" << std::endl;
22469  htmlFileP << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
22470  << std::endl;
22471  htmlFileP << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
22472  htmlFileP << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
22473  "text-align: center;}"
22474  << std::endl;
22475  htmlFileP << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
22476  htmlFileP << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
22477  htmlFileP << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
22478  htmlFileP << "</style>" << std::endl;
22479  htmlFileP << "<body>" << std::endl;
22480 
22481  if (sub == 1)
22482  htmlFileP << "<h1> Pedestals for HB, RUN = " << runnumber << " </h1>" << std::endl;
22483  if (sub == 2)
22484  htmlFileP << "<h1> Pedestals for HE, RUN = " << runnumber << " </h1>" << std::endl;
22485  if (sub == 3)
22486  htmlFileP << "<h1> Pedestals for HO, RUN = " << runnumber << " </h1>" << std::endl;
22487  if (sub == 4)
22488  htmlFileP << "<h1> Pedestals for HF, RUN = " << runnumber << " </h1>" << std::endl;
22489  htmlFileP << "<br>" << std::endl;
22490 
22491  // Pedestal:
22492  htmlFileP << "<h2> 1.Pm criterion: Pedestals for each CapID .</h3>" << std::endl;
22493  htmlFileP << "<h3> 1.A. Pedestal distribution over all events, channels for each CapID and all depths.</h3>"
22494  << std::endl;
22495  htmlFileP << "<h4> Legend: Bins less " << Pedest[0][sub] << " correpond to bad Pedestals </h4>" << std::endl;
22496  if (sub == 1)
22497  htmlFileP << " <img src=\"HistPedestalsHB.png\" />" << std::endl;
22498  if (sub == 2)
22499  htmlFileP << " <img src=\"HistPedestalsHE.png\" />" << std::endl;
22500  if (sub == 3)
22501  htmlFileP << " <img src=\"HistPedestalsHO.png\" />" << std::endl;
22502  if (sub == 4)
22503  htmlFileP << " <img src=\"HistPedestalsHF.png\" />" << std::endl;
22504  htmlFileP << "<br>" << std::endl;
22505  htmlFileP << "<h3> 1.B. Rate of channels at very low Pedestals at least in one CapID for each depth.</h3>"
22506  << std::endl;
22507  htmlFileP << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
22508  if (sub == 1)
22509  htmlFileP << " <img src=\"MapRatePedHB.png\" />" << std::endl;
22510  if (sub == 2)
22511  htmlFileP << " <img src=\"MapRatePedHE.png\" />" << std::endl;
22512  if (sub == 3)
22513  htmlFileP << " <img src=\"MapRatePedHO.png\" />" << std::endl;
22514  if (sub == 4)
22515  htmlFileP << " <img src=\"MapRatePedHF.png\" />" << std::endl;
22516 
22517  // PedestalWidth:
22518  htmlFileP << "<h2> 2.pWm criterion: Pedestal Widths for each CapID .</h3>" << std::endl;
22519  htmlFileP << "<h3> 2.A. Pedestal Widths distribution over all events, channels for each CapID and all depths.</h3>"
22520  << std::endl;
22521  htmlFileP << "<h4> Legend: Bins less " << Pedest[1][sub] << " correpond to bad Pedestal Widths </h4>" << std::endl;
22522  if (sub == 1)
22523  htmlFileP << " <img src=\"HistPedestalWidthsHB.png\" />" << std::endl;
22524  if (sub == 2)
22525  htmlFileP << " <img src=\"HistPedestalWidthsHE.png\" />" << std::endl;
22526  if (sub == 3)
22527  htmlFileP << " <img src=\"HistPedestalWidthsHO.png\" />" << std::endl;
22528  if (sub == 4)
22529  htmlFileP << " <img src=\"HistPedestalWidthsHF.png\" />" << std::endl;
22530  htmlFileP << "<br>" << std::endl;
22531  htmlFileP << "<h3> 2.B. Rate of channels at very low Pedestal Widths at least in one CapID for each depth.</h3>"
22532  << std::endl;
22533  htmlFileP << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
22534  if (sub == 1)
22535  htmlFileP << " <img src=\"MapRatePedWidthsHB.png\" />" << std::endl;
22536  if (sub == 2)
22537  htmlFileP << " <img src=\"MapRatePedWidthsHE.png\" />" << std::endl;
22538  if (sub == 3)
22539  htmlFileP << " <img src=\"MapRatePedWidthsHO.png\" />" << std::endl;
22540  if (sub == 4)
22541  htmlFileP << " <img src=\"MapRatePedWidthsHF.png\" />" << std::endl;
22542 
22543  // Correlations of Pedestal(Width) and fullAmplitude:
22544  htmlFileP << "<h2> 3.Pedestal and pedestalWidths vs Amplitude .</h3>" << std::endl;
22545  htmlFileP << "<h3> 3.A. Correlation of Pedestal(pedestalWidths) and Amplitude over all channels and events .</h3>"
22546  << std::endl;
22547  htmlFileP << "<h4> Legend: colour - entries </h4>" << std::endl;
22548  if (sub == 1)
22549  htmlFileP << "<img src=\"CorrelationsMapPedestalVsfullAmplitudeHB.png\" />" << std::endl;
22550  if (sub == 2)
22551  htmlFileP << "<img src=\"CorrelationsMapPedestalVsfullAmplitudeHE.png\" />" << std::endl;
22552  if (sub == 3)
22553  htmlFileP << "<img src=\"CorrelationsMapPedestalVsfullAmplitudeHO.png\" />" << std::endl;
22554  if (sub == 4)
22555  htmlFileP << "<img src=\"CorrelationsMapPedestalVsfullAmplitudeHF.png\" />" << std::endl;
22556  htmlFileP << "<br>" << std::endl;
22557  htmlFileP.close();
22558 
22559  // TSs Shapes:
22560 
22561  htmlFileS << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
22562  htmlFileS << "<head>" << std::endl;
22563  htmlFileS << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
22564  htmlFileS << "<title> Remote Monitoring Tool </title>" << std::endl;
22565  htmlFileS << "<style type=\"text/css\">" << std::endl;
22566  htmlFileS << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
22567  << std::endl;
22568  htmlFileS << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
22569  htmlFileS << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
22570  "text-align: center;}"
22571  << std::endl;
22572  htmlFileS << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
22573  htmlFileS << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
22574  htmlFileS << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
22575  htmlFileS << "</style>" << std::endl;
22576  htmlFileS << "<body>" << std::endl;
22577 
22578  if (sub == 1)
22579  htmlFileS << "<h1> ADC Shape for HB, RUN = " << runnumber << " </h1>" << std::endl;
22580  if (sub == 2)
22581  htmlFileS << "<h1> ADC Shape for HE, RUN = " << runnumber << " </h1>" << std::endl;
22582  if (sub == 3)
22583  htmlFileS << "<h1> ADC Shape for HO, RUN = " << runnumber << " </h1>" << std::endl;
22584  if (sub == 4)
22585  htmlFileS << "<h1> ADC Shape for HF, RUN = " << runnumber << " </h1>" << std::endl;
22586  htmlFileS << "<br>" << std::endl;
22587 
22588  htmlFileS << "<h2> 1.Mean ADC Shape.</h3>" << std::endl;
22589  htmlFileS << "<h3> 1.A. ADC shape averaged over all good channels, depth and events.</h3>" << std::endl;
22590  // htmlFileS << "<h4> Legend: Bins less "<<Pedest[0][sub]<<" correpond to bad Pedestals </h4>"<< std::endl;
22591  if (sub == 1)
22592  htmlFileS << " <img src=\"HistGoodTSshapesHB.png\" />" << std::endl;
22593  if (sub == 2)
22594  htmlFileS << " <img src=\"HistGoodTSshapesHE.png\" />" << std::endl;
22595  if (sub == 3)
22596  htmlFileS << " <img src=\"HistGoodTSshapesHO.png\" />" << std::endl;
22597  if (sub == 4)
22598  htmlFileS << " <img src=\"HistGoodTSshapesHF.png\" />" << std::endl;
22599  htmlFileS << "<br>" << std::endl;
22600  htmlFileS << "<h3> 1.B. ADC shape averaged over all bad channels, depth and events. Bad channels are selected by 5 "
22601  "criteria: CapId, A, W, P, Pw </h3>"
22602  << std::endl;
22603  // htmlFileS << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22604  if (sub == 1)
22605  htmlFileS << " <img src=\"HistBadTSshapesHB.png\" />" << std::endl;
22606  if (sub == 2)
22607  htmlFileS << " <img src=\"HistBadTSshapesHE.png\" />" << std::endl;
22608  if (sub == 3)
22609  htmlFileS << " <img src=\"HistBadTSshapesHO.png\" />" << std::endl;
22610  if (sub == 4)
22611  htmlFileS << " <img src=\"HistBadTSshapesHF.png\" />" << std::endl;
22612 
22613  htmlFileS << "<h2> 2. Occupancy and rates of non-zero amplitudes for separate TSs in Sub-Detector over "
22614  "depth,eta.phi </h3>"
22615  << std::endl;
22616  htmlFileS << "<h3> 2.A. reminder:.......................... for HBHE, TS=2;...................................... "
22617  "for HF, TS=1;..................................... for HO, TS=0,1,2 </h3>"
22618  << std::endl;
22619  if (sub == 1)
22620  htmlFileS << " <img src=\"Hist_mapDepthAllTS2_HB.png\" />" << std::endl;
22621  if (sub == 2)
22622  htmlFileS << " <img src=\"Hist_mapDepthAllTS2_HE.png\" />" << std::endl;
22623  if (sub == 3)
22624  htmlFileS << " <img src=\"Hist_mapDepthAllTS012_HO.png\" />" << std::endl;
22625  if (sub == 4)
22626  htmlFileS << " <img src=\"Hist_mapDepthAllTS1_HF.png\" />" << std::endl;
22627  htmlFileS << "<br>" << std::endl;
22628 
22629  /*
22630  htmlFileS << "<h2> 2. ADC in Time Slice </h3>"<< std::endl;
22631  htmlFileS << "<h3> 2.A. ADC counts histogrammed over all channels, depth and events.</h3>"<< std::endl;
22632 // htmlFileS << "<h4> Legend: Bins less "<<Pedest[0][sub]<<" correpond to bad Pedestals </h4>"<< std::endl;
22633  if (sub==1) htmlFileS << " <img src=\"Hist_ADC_HB_All.png\" />" << std::endl;
22634  if (sub==2) htmlFileS << " <img src=\"Hist_ADC_HE_All.png\" />" << std::endl;
22635  if (sub==3) htmlFileS << " <img src=\"Hist_ADC_HO_All.png\" />" << std::endl;
22636  if (sub==4) htmlFileS << " <img src=\"Hist_ADC_HF_All.png\" />" << std::endl;
22637  htmlFileS << "<br>"<< std::endl;
22638  htmlFileS << "<h3> 2.B. ADC counts histogrammed over all channels and events for each depth separately. </h3>"<< std::endl;
22639 // htmlFileS << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22640  if (sub==1) htmlFileS << " <img src=\"Hist_ADC_HB_DS.png\" />" << std::endl;
22641  if (sub==2) htmlFileS << " <img src=\"Hist_ADC_HE_DS.png\" />" << std::endl;
22642  if (sub==3) htmlFileS << " <img src=\"Hist_ADC_HO_DS.png\" />" << std::endl;
22643  if (sub==4) htmlFileS << " <img src=\"Hist_ADC_HF_DS.png\" />" << std::endl;
22644 
22645  htmlFileS << "<h2> 3. ADC Sum in Time Slice </h3>"<< std::endl;
22646  htmlFileS << "<h3> 3.A. ADC Sum over all channels histogrammed over all events for each depth separately. </h3>"<< std::endl;
22647 // htmlFileS << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22648  if (sub==1) htmlFileS << " <img src=\"Hist_SumADC_HB.png\" />" << std::endl;
22649  if (sub==2) htmlFileS << " <img src=\"Hist_SumADC_HE.png\" />" << std::endl;
22650  if (sub==3) htmlFileS << " <img src=\"Hist_SumADC_HO.png\" />" << std::endl;
22651  if (sub==4) htmlFileS << " <img src=\"Hist_SumADC_HF.png\" />" << std::endl;
22652 
22653  htmlFileS << "<h3> 3.B. ADC Sum over all channels histogrammed over all events for each depth separately. </h3>"<< std::endl;
22654 // htmlFileS << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22655  if (sub==1) htmlFileS << " <img src=\"Hist_SumADC_HB0.png\" />" << std::endl;
22656  if (sub==2) htmlFileS << " <img src=\"Hist_SumADC_HE0.png\" />" << std::endl;
22657  if (sub==3) htmlFileS << " <img src=\"Hist_SumADC_HO0.png\" />" << std::endl;
22658  if (sub==4) htmlFileS << " <img src=\"Hist_SumADC_HF0.png\" />" << std::endl;
22659 
22660  htmlFileS << "<h3> 3.C. ADC Sum over all channels histogrammed over all events for each depth separately. </h3>"<< std::endl;
22661 // htmlFileS << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22662  if (sub==1) htmlFileS << " <img src=\"Hist_SumADC_HB1.png\" />" << std::endl;
22663  if (sub==2) htmlFileS << " <img src=\"Hist_SumADC_HE1.png\" />" << std::endl;
22664  if (sub==3) htmlFileS << " <img src=\"Hist_SumADC_HO1.png\" />" << std::endl;
22665  if (sub==4) htmlFileS << " <img src=\"Hist_SumADC_HF1.png\" />" << std::endl;
22666 */
22667  htmlFileS.close();
22668 
22670 
22672 
22674 
22675  htmlFileM << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
22676  htmlFileM << "<head>" << std::endl;
22677  htmlFileM << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
22678  htmlFileM << "<title> Remote Monitoring Tool </title>" << std::endl;
22679  htmlFileM << "<style type=\"text/css\">" << std::endl;
22680  htmlFileM << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
22681  << std::endl;
22682  htmlFileM << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
22683  htmlFileM << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
22684  "text-align: center;}"
22685  << std::endl;
22686  htmlFileM << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
22687  htmlFileM << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
22688  htmlFileM << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
22689  htmlFileM << "</style>" << std::endl;
22690  htmlFileM << "<body>" << std::endl;
22691 
22693 
22694  if (sub == 1)
22695  htmlFileM << "<h1> Digis Phi-symmetry for Calibration Group, HB, RUN = " << runnumber << " </h1>" << std::endl;
22696  if (sub == 2)
22697  htmlFileM << "<h1> Digis Phi-symmetry for Calibration Group, HE, RUN = " << runnumber << " </h1>" << std::endl;
22698  if (sub == 4)
22699  htmlFileM << "<h1> Digis Phi-symmetry for Calibration Group, HF, RUN = " << runnumber << " </h1>" << std::endl;
22700  htmlFileM << "<br>" << std::endl;
22701 
22702  htmlFileM << "<h2> 1: R = R_depth_ieta_iphi = E_depth_ieta_iphi/E_depth_ieta </h3>" << std::endl;
22703  htmlFileM << "<h3> 1A: eta/phi-plot: R, averaged over depthes </h3>" << std::endl;
22704  // htmlFileM << "<h4> Legend: Bins less "<<Pedest[0][sub]<<" correpond to bad Pedestals </h4>"<< std::endl;
22705  if (sub == 1)
22706  htmlFileM << " <img src=\"RdigiGeneralD2PhiSymmetryHB.png\" />" << std::endl;
22707  if (sub == 2)
22708  htmlFileM << " <img src=\"RdigiGeneralD2PhiSymmetryHE.png\" />" << std::endl;
22709  if (sub == 4)
22710  htmlFileM << " <img src=\"RdigiGeneralD2PhiSymmetryHF.png\" />" << std::endl;
22711  htmlFileM << "<br>" << std::endl;
22712 
22713  htmlFileM << "<h3> 1B: R vs phi , averaged over depthes & eta </h3>" << std::endl;
22714  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22715  if (sub == 1)
22716  htmlFileM << " <img src=\"RdigiGeneralD1PhiSymmetryHB.png\" />" << std::endl;
22717  if (sub == 2)
22718  htmlFileM << " <img src=\"RdigiGeneralD1PhiSymmetryHE.png\" />" << std::endl;
22719  if (sub == 4)
22720  htmlFileM << " <img src=\"RdigiGeneralD1PhiSymmetryHF.png\" />" << std::endl;
22721  htmlFileM << "<br>" << std::endl;
22722 
22724 
22726  htmlFileM << "<h2> Positive direction, R = R_depth_ieta_iphi = E_depth_ieta_iphi/E_depth_ieta </h3>" << std::endl;
22727  htmlFileM << "<h3> 1C: R vs phi , different eta, Depth1 </h3>" << std::endl;
22728  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22729  if (sub == 1)
22730  htmlFileM << " <img src=\"RdigiPositiveDirectionhistD1PhiSymmetryDepth1HB.png\" />" << std::endl;
22731  if (sub == 2)
22732  htmlFileM << " <img src=\"RdigiPositiveDirectionhistD1PhiSymmetryDepth1HE.png\" />" << std::endl;
22733  if (sub == 4)
22734  htmlFileM << " <img src=\"RdigiPositiveDirectionhistD1PhiSymmetryDepth1HF.png\" />" << std::endl;
22735  htmlFileM << "<br>" << std::endl;
22736 
22737  htmlFileM << "<h3> 1D: R vs phi , different eta, Depth2 </h3>" << std::endl;
22738  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22739  if (sub == 1)
22740  htmlFileM << " <img src=\"RdigiPositiveDirectionhistD1PhiSymmetryDepth2HB.png\" />" << std::endl;
22741  if (sub == 2)
22742  htmlFileM << " <img src=\"RdigiPositiveDirectionhistD1PhiSymmetryDepth2HE.png\" />" << std::endl;
22743  if (sub == 4)
22744  htmlFileM << " <img src=\"RdigiPositiveDirectionhistD1PhiSymmetryDepth2HF.png\" />" << std::endl;
22745  htmlFileM << "<br>" << std::endl;
22746 
22747  htmlFileM << "<h3> 1E: R vs phi , different eta, Depth3 </h3>" << std::endl;
22748  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22749  if (sub == 1)
22750  htmlFileM << " <img src=\"RdigiPositiveDirectionhistD1PhiSymmetryDepth3HB.png\" />" << std::endl;
22751  if (sub == 2)
22752  htmlFileM << " <img src=\"RdigiPositiveDirectionhistD1PhiSymmetryDepth3HE.png\" />" << std::endl;
22753  if (sub == 4)
22754  htmlFileM << " <img src=\"RdigiPositiveDirectionhistD1PhiSymmetryDepth3HF.png\" />" << std::endl;
22755  htmlFileM << "<br>" << std::endl;
22756 
22757  htmlFileM << "<h3> 1F: R vs phi , different eta, Depth4 </h3>" << std::endl;
22758  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22759  if (sub == 1)
22760  htmlFileM << " <img src=\"RdigiPositiveDirectionhistD1PhiSymmetryDepth4HB.png\" />" << std::endl;
22761  if (sub == 2)
22762  htmlFileM << " <img src=\"RdigiPositiveDirectionhistD1PhiSymmetryDepth4HE.png\" />" << std::endl;
22763  if (sub == 4)
22764  htmlFileM << " <img src=\"RdigiPositiveDirectionhistD1PhiSymmetryDepth4HF.png\" />" << std::endl;
22765  htmlFileM << "<br>" << std::endl;
22766 
22767  if (sub == 2)
22768  htmlFileM << "<h3> 1G: R vs phi , different eta, Depth5 </h3>" << std::endl;
22769  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22770  if (sub == 2)
22771  htmlFileM << " <img src=\"RdigiPositiveDirectionhistD1PhiSymmetryDepth5HE.png\" />" << std::endl;
22772  htmlFileM << "<br>" << std::endl;
22773 
22774  if (sub == 2)
22775  htmlFileM << "<h3> 1H: R vs phi , different eta, Depth6 </h3>" << std::endl;
22776  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22777  if (sub == 2)
22778  htmlFileM << " <img src=\"RdigiPositiveDirectionhistD1PhiSymmetryDepth6HE.png\" />" << std::endl;
22779  htmlFileM << "<br>" << std::endl;
22780 
22781  if (sub == 2)
22782  htmlFileM << "<h3> 1I: R vs phi , different eta, Depth7 </h3>" << std::endl;
22783  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22784  if (sub == 2)
22785  htmlFileM << " <img src=\"RdigiPositiveDirectionhistD1PhiSymmetryDepth7HE.png\" />" << std::endl;
22786  htmlFileM << "<br>" << std::endl;
22787 
22789  htmlFileM << "<h2> 2: D(digivarianceSignalhe) </h3>" << std::endl;
22790  htmlFileM << "<h3> 2A: eta/phi-plot: D(digivarianceSignalhe), averaged over depthes </h3>" << std::endl;
22791  // htmlFileM << "<h4> Legend: Bins less "<<Pedest[0][sub]<<" correpond to bad Pedestals </h4>"<< std::endl;
22792  if (sub == 1)
22793  htmlFileM << " <img src=\"DdigiGeneralD2PhiSymmetryHB.png\" />" << std::endl;
22794  if (sub == 2)
22795  htmlFileM << " <img src=\"DdigiGeneralD2PhiSymmetryHE.png\" />" << std::endl;
22796  if (sub == 4)
22797  htmlFileM << " <img src=\"DdigiGeneralD2PhiSymmetryHF.png\" />" << std::endl;
22798  htmlFileM << "<br>" << std::endl;
22799 
22800  htmlFileM << "<h3> 2B: D(digivarianceSignalhe) vs phi , averaged over depthes & eta </h3>" << std::endl;
22801  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22802  if (sub == 1)
22803  htmlFileM << " <img src=\"DdigiGeneralD1PhiSymmetryHB.png\" />" << std::endl;
22804  if (sub == 2)
22805  htmlFileM << " <img src=\"DdigiGeneralD1PhiSymmetryHE.png\" />" << std::endl;
22806  if (sub == 4)
22807  htmlFileM << " <img src=\"DdigiGeneralD1PhiSymmetryHF.png\" />" << std::endl;
22808  htmlFileM << "<br>" << std::endl;
22809 
22812  htmlFileM << "<h2> Positive direction, D(digivarianceSignalhe) </h3>" << std::endl;
22813  htmlFileM << "<h3> 2C: D(digivarianceSignalhe) vs phi , different eta, Depth1 </h3>" << std::endl;
22814  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22815  if (sub == 1)
22816  htmlFileM << " <img src=\"DdigiPositiveDirectionhistD1PhiSymmetryDepth1HB.png\" />" << std::endl;
22817  if (sub == 2)
22818  htmlFileM << " <img src=\"DdigiPositiveDirectionhistD1PhiSymmetryDepth1HE.png\" />" << std::endl;
22819  if (sub == 4)
22820  htmlFileM << " <img src=\"DdigiPositiveDirectionhistD1PhiSymmetryDepth1HF.png\" />" << std::endl;
22821  htmlFileM << "<br>" << std::endl;
22822 
22823  htmlFileM << "<h3> 2.D. D(digivarianceSignalhe) vs phi , different eta, Depth2 </h3>" << std::endl;
22824  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22825  if (sub == 1)
22826  htmlFileM << " <img src=\"DdigiPositiveDirectionhistD1PhiSymmetryDepth2HB.png\" />" << std::endl;
22827  if (sub == 2)
22828  htmlFileM << " <img src=\"DdigiPositiveDirectionhistD1PhiSymmetryDepth2HE.png\" />" << std::endl;
22829  if (sub == 4)
22830  htmlFileM << " <img src=\"DdigiPositiveDirectionhistD1PhiSymmetryDepth2HF.png\" />" << std::endl;
22831  htmlFileM << "<br>" << std::endl;
22832 
22833  htmlFileM << "<h3> 2E: D(digivarianceSignalhe) vs phi , different eta, Depth3 </h3>" << std::endl;
22834  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22835  if (sub == 1)
22836  htmlFileM << " <img src=\"DdigiPositiveDirectionhistD1PhiSymmetryDepth3HB.png\" />" << std::endl;
22837  if (sub == 2)
22838  htmlFileM << " <img src=\"DdigiPositiveDirectionhistD1PhiSymmetryDepth3HE.png\" />" << std::endl;
22839  if (sub == 4)
22840  htmlFileM << " <img src=\"DdigiPositiveDirectionhistD1PhiSymmetryDepth3HF.png\" />" << std::endl;
22841  htmlFileM << "<br>" << std::endl;
22842 
22843  htmlFileM << "<h3> 2F: D(digivarianceSignalhe) vs phi , different eta, Depth4 </h3>" << std::endl;
22844  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22845  if (sub == 1)
22846  htmlFileM << " <img src=\"DdigiPositiveDirectionhistD1PhiSymmetryDepth4HB.png\" />" << std::endl;
22847  if (sub == 2)
22848  htmlFileM << " <img src=\"DdigiPositiveDirectionhistD1PhiSymmetryDepth4HE.png\" />" << std::endl;
22849  if (sub == 4)
22850  htmlFileM << " <img src=\"DdigiPositiveDirectionhistD1PhiSymmetryDepth4HF.png\" />" << std::endl;
22851  htmlFileM << "<br>" << std::endl;
22852 
22853  if (sub == 2)
22854  htmlFileM << "<h3> 2G: D(digivarianceSignalhe) vs phi , different eta, Depth5 </h3>" << std::endl;
22855  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22856  if (sub == 2)
22857  htmlFileM << " <img src=\"DdigiPositiveDirectionhistD1PhiSymmetryDepth5HE.png\" />" << std::endl;
22858  htmlFileM << "<br>" << std::endl;
22859 
22860  if (sub == 2)
22861  htmlFileM << "<h3> 2H: D(digivarianceSignalhe) vs phi , different eta, Depth6 </h3>" << std::endl;
22862  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22863  if (sub == 2)
22864  htmlFileM << " <img src=\"DdigiPositiveDirectionhistD1PhiSymmetryDepth6HE.png\" />" << std::endl;
22865  htmlFileM << "<br>" << std::endl;
22866 
22867  if (sub == 2)
22868  htmlFileM << "<h3> 2I: D(digivarianceSignalhe) vs phi , different eta, Depth7 </h3>" << std::endl;
22869  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22870  if (sub == 2)
22871  htmlFileM << " <img src=\"DdigiPositiveDirectionhistD1PhiSymmetryDepth7HE.png\" />" << std::endl;
22872  htmlFileM << "<br>" << std::endl;
22873 
22876  htmlFileM << "<h2> 3: Negative direction, R = R_depth_ieta_iphi = E_depth_ieta_iphi/E_depth_ieta </h3>"
22877  << std::endl;
22878 
22880  htmlFileM << "<h3> 3C: R vs phi , different eta, Depth1 </h3>" << std::endl;
22881  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22882  if (sub == 1)
22883  htmlFileM << " <img src=\"RdigiNegativeDirectionhistD1PhiSymmetryDepth1HB.png\" />" << std::endl;
22884  if (sub == 2)
22885  htmlFileM << " <img src=\"RdigiNegativeDirectionhistD1PhiSymmetryDepth1HE.png\" />" << std::endl;
22886  if (sub == 4)
22887  htmlFileM << " <img src=\"RdigiNegativeDirectionhistD1PhiSymmetryDepth1HF.png\" />" << std::endl;
22888  htmlFileM << "<br>" << std::endl;
22889 
22890  htmlFileM << "<h3> 3D: R vs phi , different eta, Depth2 </h3>" << std::endl;
22891  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22892  if (sub == 1)
22893  htmlFileM << " <img src=\"RdigiNegativeDirectionhistD1PhiSymmetryDepth2HB.png\" />" << std::endl;
22894  if (sub == 2)
22895  htmlFileM << " <img src=\"RdigiNegativeDirectionhistD1PhiSymmetryDepth2HE.png\" />" << std::endl;
22896  if (sub == 4)
22897  htmlFileM << " <img src=\"RdigiNegativeDirectionhistD1PhiSymmetryDepth2HF.png\" />" << std::endl;
22898  htmlFileM << "<br>" << std::endl;
22899 
22900  htmlFileM << "<h3> 3E: R vs phi , different eta, Depth3 </h3>" << std::endl;
22901  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22902  if (sub == 1)
22903  htmlFileM << " <img src=\"RdigiNegativeDirectionhistD1PhiSymmetryDepth3HB.png\" />" << std::endl;
22904  if (sub == 2)
22905  htmlFileM << " <img src=\"RdigiNegativeDirectionhistD1PhiSymmetryDepth3HE.png\" />" << std::endl;
22906  if (sub == 4)
22907  htmlFileM << " <img src=\"RdigiNegativeDirectionhistD1PhiSymmetryDepth3HF.png\" />" << std::endl;
22908  htmlFileM << "<br>" << std::endl;
22909 
22910  htmlFileM << "<h3> 3F: R vs phi , different eta, Depth4 </h3>" << std::endl;
22911  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22912  if (sub == 1)
22913  htmlFileM << " <img src=\"RdigiNegativeDirectionhistD1PhiSymmetryDepth4HB.png\" />" << std::endl;
22914  if (sub == 2)
22915  htmlFileM << " <img src=\"RdigiNegativeDirectionhistD1PhiSymmetryDepth4HE.png\" />" << std::endl;
22916  if (sub == 4)
22917  htmlFileM << " <img src=\"RdigiNegativeDirectionhistD1PhiSymmetryDepth4HF.png\" />" << std::endl;
22918  htmlFileM << "<br>" << std::endl;
22919 
22920  if (sub == 2)
22921  htmlFileM << "<h3> 3G: R vs phi , different eta, Depth5 </h3>" << std::endl;
22922  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22923  if (sub == 2)
22924  htmlFileM << " <img src=\"RdigiNegativeDirectionhistD1PhiSymmetryDepth5HE.png\" />" << std::endl;
22925  htmlFileM << "<br>" << std::endl;
22926 
22927  if (sub == 2)
22928  htmlFileM << "<h3> 3H: R vs phi , different eta, Depth6 </h3>" << std::endl;
22929  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22930  if (sub == 2)
22931  htmlFileM << " <img src=\"RdigiNegativeDirectionhistD1PhiSymmetryDepth6HE.png\" />" << std::endl;
22932  htmlFileM << "<br>" << std::endl;
22933 
22934  if (sub == 2)
22935  htmlFileM << "<h3> 3I: R vs phi , different eta, Depth7 </h3>" << std::endl;
22936  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22937  if (sub == 2)
22938  htmlFileM << " <img src=\"RdigiNegativeDirectionhistD1PhiSymmetryDepth7HE.png\" />" << std::endl;
22939  htmlFileM << "<br>" << std::endl;
22940 
22942  htmlFileM << "<h2> 4: Negative direction, D(digivarianceSignalhe) </h3>" << std::endl;
22944  htmlFileM << "<h3> 4C: D(digivarianceSignalhe) vs phi , different eta, Depth1 </h3>" << std::endl;
22945  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22946  if (sub == 1)
22947  htmlFileM << " <img src=\"DdigiNegativeDirectionhistD1PhiSymmetryDepth1HB.png\" />" << std::endl;
22948  if (sub == 2)
22949  htmlFileM << " <img src=\"DdigiNegativeDirectionhistD1PhiSymmetryDepth1HE.png\" />" << std::endl;
22950  if (sub == 4)
22951  htmlFileM << " <img src=\"DdigiNegativeDirectionhistD1PhiSymmetryDepth1HF.png\" />" << std::endl;
22952  htmlFileM << "<br>" << std::endl;
22953 
22954  htmlFileM << "<h3> 4.D. D(digivarianceSignalhe) vs phi , different eta, Depth2 </h3>" << std::endl;
22955  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22956  if (sub == 1)
22957  htmlFileM << " <img src=\"DdigiNegativeDirectionhistD1PhiSymmetryDepth2HB.png\" />" << std::endl;
22958  if (sub == 2)
22959  htmlFileM << " <img src=\"DdigiNegativeDirectionhistD1PhiSymmetryDepth2HE.png\" />" << std::endl;
22960  if (sub == 4)
22961  htmlFileM << " <img src=\"DdigiNegativeDirectionhistD1PhiSymmetryDepth2HF.png\" />" << std::endl;
22962  htmlFileM << "<br>" << std::endl;
22963 
22964  htmlFileM << "<h3> 4E: D(digivarianceSignalhe) vs phi , different eta, Depth3 </h3>" << std::endl;
22965  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22966  if (sub == 1)
22967  htmlFileM << " <img src=\"DdigiNegativeDirectionhistD1PhiSymmetryDepth3HB.png\" />" << std::endl;
22968  if (sub == 2)
22969  htmlFileM << " <img src=\"DdigiNegativeDirectionhistD1PhiSymmetryDepth3HE.png\" />" << std::endl;
22970  if (sub == 4)
22971  htmlFileM << " <img src=\"DdigiNegativeDirectionhistD1PhiSymmetryDepth3HF.png\" />" << std::endl;
22972  htmlFileM << "<br>" << std::endl;
22973 
22974  htmlFileM << "<h3> 4F: D(digivarianceSignalhe) vs phi , different eta, Depth4 </h3>" << std::endl;
22975  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22976  if (sub == 1)
22977  htmlFileM << " <img src=\"DdigiNegativeDirectionhistD1PhiSymmetryDepth4HB.png\" />" << std::endl;
22978  if (sub == 2)
22979  htmlFileM << " <img src=\"DdigiNegativeDirectionhistD1PhiSymmetryDepth4HE.png\" />" << std::endl;
22980  if (sub == 4)
22981  htmlFileM << " <img src=\"DdigiNegativeDirectionhistD1PhiSymmetryDepth4HF.png\" />" << std::endl;
22982  htmlFileM << "<br>" << std::endl;
22983 
22984  if (sub == 2)
22985  htmlFileM << "<h3> 4G: D(digivarianceSignalhe) vs phi , different eta, Depth5 </h3>" << std::endl;
22986  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22987  if (sub == 2)
22988  htmlFileM << " <img src=\"DdigiNegativeDirectionhistD1PhiSymmetryDepth5HE.png\" />" << std::endl;
22989  htmlFileM << "<br>" << std::endl;
22990 
22991  if (sub == 2)
22992  htmlFileM << "<h3> 4H: D(digivarianceSignalhe) vs phi , different eta, Depth6 </h3>" << std::endl;
22993  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
22994  if (sub == 2)
22995  htmlFileM << " <img src=\"DdigiNegativeDirectionhistD1PhiSymmetryDepth6HE.png\" />" << std::endl;
22996  htmlFileM << "<br>" << std::endl;
22997 
22998  if (sub == 2)
22999  htmlFileM << "<h3> 4I: D(digivarianceSignalhe) vs phi , different eta, Depth7 </h3>" << std::endl;
23000  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23001  if (sub == 2)
23002  htmlFileM << " <img src=\"DdigiNegativeDirectionhistD1PhiSymmetryDepth7HE.png\" />" << std::endl;
23003  htmlFileM << "<br>" << std::endl;
23005  htmlFileM.close();
23007  //
23011 
23012  htmlFileR << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
23013  htmlFileR << "<head>" << std::endl;
23014  htmlFileR << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
23015  htmlFileR << "<title> Remote Monitoring Tool </title>" << std::endl;
23016  htmlFileR << "<style type=\"text/css\">" << std::endl;
23017  htmlFileR << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
23018  << std::endl;
23019  htmlFileR << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
23020  htmlFileR << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
23021  "text-align: center;}"
23022  << std::endl;
23023  htmlFileR << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
23024  htmlFileR << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
23025  htmlFileR << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
23026  htmlFileR << "</style>" << std::endl;
23027  htmlFileR << "<body>" << std::endl;
23028 
23030 
23031  if (sub == 1)
23032  htmlFileR << "<h1> RecoSignal Phi-symmetry for Calibration Group, HB, RUN = " << runnumber << " </h1>"
23033  << std::endl;
23034  if (sub == 2)
23035  htmlFileR << "<h1> RecoSignal Phi-symmetry for Calibration Group, HE, RUN = " << runnumber << " </h1>"
23036  << std::endl;
23037  if (sub == 4)
23038  htmlFileR << "<h1> RecoSignal Phi-symmetry for Calibration Group, HF, RUN = " << runnumber << " </h1>"
23039  << std::endl;
23040  htmlFileR << "<br>" << std::endl;
23041 
23042  htmlFileR << "<h2> 1: R = R_depth_ieta_iphi = E_depth_ieta_iphi/E_depth_ieta </h3>" << std::endl;
23043  htmlFileR << "<h3> 1A: eta/phi-plot: R, averaged over depthes </h3>" << std::endl;
23044  // htmlFileR << "<h4> Legend: Bins less "<<Pedest[0][sub]<<" correpond to bad Pedestals </h4>"<< std::endl;
23045  if (sub == 1)
23046  htmlFileR << " <img src=\"RrecosignalGeneralD2PhiSymmetryHB.png\" />" << std::endl;
23047  if (sub == 2)
23048  htmlFileR << " <img src=\"RrecosignalGeneralD2PhiSymmetryHE.png\" />" << std::endl;
23049  if (sub == 4)
23050  htmlFileR << " <img src=\"RrecosignalGeneralD2PhiSymmetryHF.png\" />" << std::endl;
23051  htmlFileR << "<br>" << std::endl;
23052 
23053  htmlFileR << "<h3> 1B: R vs phi , averaged over depthes & eta </h3>" << std::endl;
23054  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23055  if (sub == 1)
23056  htmlFileR << " <img src=\"RrecosignalGeneralD1PhiSymmetryHB.png\" />" << std::endl;
23057  if (sub == 2)
23058  htmlFileR << " <img src=\"RrecosignalGeneralD1PhiSymmetryHE.png\" />" << std::endl;
23059  if (sub == 4)
23060  htmlFileR << " <img src=\"RrecosignalGeneralD1PhiSymmetryHF.png\" />" << std::endl;
23061  htmlFileR << "<br>" << std::endl;
23062 
23064 
23066  htmlFileR << "<h2> Positive direction, R = R_depth_ieta_iphi = E_depth_ieta_iphi/E_depth_ieta </h3>" << std::endl;
23067  htmlFileR << "<h3> 1C: R vs phi , different eta, Depth1 </h3>" << std::endl;
23068  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23069  if (sub == 1)
23070  htmlFileR << " <img src=\"RrecosignalPositiveDirectionhistD1PhiSymmetryDepth1HB.png\" />" << std::endl;
23071  if (sub == 2)
23072  htmlFileR << " <img src=\"RrecosignalPositiveDirectionhistD1PhiSymmetryDepth1HE.png\" />" << std::endl;
23073  if (sub == 4)
23074  htmlFileR << " <img src=\"RrecosignalPositiveDirectionhistD1PhiSymmetryDepth1HF.png\" />" << std::endl;
23075  htmlFileR << "<br>" << std::endl;
23076 
23077  htmlFileR << "<h3> 1D: R vs phi , different eta, Depth2 </h3>" << std::endl;
23078  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23079  if (sub == 1)
23080  htmlFileR << " <img src=\"RrecosignalPositiveDirectionhistD1PhiSymmetryDepth2HB.png\" />" << std::endl;
23081  if (sub == 2)
23082  htmlFileR << " <img src=\"RrecosignalPositiveDirectionhistD1PhiSymmetryDepth2HE.png\" />" << std::endl;
23083  if (sub == 4)
23084  htmlFileR << " <img src=\"RrecosignalPositiveDirectionhistD1PhiSymmetryDepth2HF.png\" />" << std::endl;
23085  htmlFileR << "<br>" << std::endl;
23086 
23087  if (sub == 1 || sub == 2)
23088  htmlFileR << "<h3> 1E: R vs phi , different eta, Depth3 </h3>" << std::endl;
23089  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23090  if (sub == 1)
23091  htmlFileR << " <img src=\"RrecosignalPositiveDirectionhistD1PhiSymmetryDepth3HB.png\" />" << std::endl;
23092  if (sub == 2)
23093  htmlFileR << " <img src=\"RrecosignalPositiveDirectionhistD1PhiSymmetryDepth3HE.png\" />" << std::endl;
23094  htmlFileR << "<br>" << std::endl;
23095 
23096  if (sub == 1 || sub == 2)
23097  htmlFileR << "<h3> 1F: R vs phi , different eta, Depth4 </h3>" << std::endl;
23098  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23099  if (sub == 1)
23100  htmlFileR << " <img src=\"RrecosignalPositiveDirectionhistD1PhiSymmetryDepth4HB.png\" />" << std::endl;
23101  if (sub == 2)
23102  htmlFileR << " <img src=\"RrecosignalPositiveDirectionhistD1PhiSymmetryDepth4HE.png\" />" << std::endl;
23103  htmlFileR << "<br>" << std::endl;
23104 
23105  if (sub == 2)
23106  htmlFileR << "<h3> 1G: R vs phi , different eta, Depth5 </h3>" << std::endl;
23107  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23108  if (sub == 2)
23109  htmlFileR << " <img src=\"RrecosignalPositiveDirectionhistD1PhiSymmetryDepth5HE.png\" />" << std::endl;
23110  htmlFileR << "<br>" << std::endl;
23111 
23112  if (sub == 2)
23113  htmlFileR << "<h3> 1H: R vs phi , different eta, Depth6 </h3>" << std::endl;
23114  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23115  if (sub == 2)
23116  htmlFileR << " <img src=\"RrecosignalPositiveDirectionhistD1PhiSymmetryDepth6HE.png\" />" << std::endl;
23117  htmlFileR << "<br>" << std::endl;
23118 
23119  if (sub == 2)
23120  htmlFileR << "<h3> 1I: R vs phi , different eta, Depth7 </h3>" << std::endl;
23121  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23122  if (sub == 2)
23123  htmlFileR << " <img src=\"RrecosignalPositiveDirectionhistD1PhiSymmetryDepth7HE.png\" />" << std::endl;
23124  htmlFileR << "<br>" << std::endl;
23125 
23127  htmlFileR << "<h2> 2: D(recosignalvarianceSignalhe) </h3>" << std::endl;
23128  htmlFileR << "<h3> 2A: eta/phi-plot: D(recosignalvarianceSignalhe), averaged over depthes </h3>" << std::endl;
23129  // htmlFileR << "<h4> Legend: Bins less "<<Pedest[0][sub]<<" correpond to bad Pedestals </h4>"<< std::endl;
23130  if (sub == 1)
23131  htmlFileR << " <img src=\"DrecosignalGeneralD2PhiSymmetryHB.png\" />" << std::endl;
23132  if (sub == 2)
23133  htmlFileR << " <img src=\"DrecosignalGeneralD2PhiSymmetryHE.png\" />" << std::endl;
23134  if (sub == 4)
23135  htmlFileR << " <img src=\"DrecosignalGeneralD2PhiSymmetryHF.png\" />" << std::endl;
23136  htmlFileR << "<br>" << std::endl;
23137 
23138  htmlFileR << "<h3> 2B: D(recosignalvarianceSignalhe) vs phi , averaged over depthes & eta </h3>" << std::endl;
23139  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23140  if (sub == 1)
23141  htmlFileR << " <img src=\"DrecosignalGeneralD1PhiSymmetryHB.png\" />" << std::endl;
23142  if (sub == 2)
23143  htmlFileR << " <img src=\"DrecosignalGeneralD1PhiSymmetryHE.png\" />" << std::endl;
23144  if (sub == 4)
23145  htmlFileR << " <img src=\"DrecosignalGeneralD1PhiSymmetryHF.png\" />" << std::endl;
23146  htmlFileR << "<br>" << std::endl;
23147 
23150  htmlFileR << "<h2> Positive direction, D(recosignalvarianceSignalhe) </h3>" << std::endl;
23151  htmlFileR << "<h3> 2C: D(recosignalvarianceSignalhe) vs phi , different eta, Depth1 </h3>" << std::endl;
23152  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23153  if (sub == 1)
23154  htmlFileR << " <img src=\"DrecosignalPositiveDirectionhistD1PhiSymmetryDepth1HB.png\" />" << std::endl;
23155  if (sub == 2)
23156  htmlFileR << " <img src=\"DrecosignalPositiveDirectionhistD1PhiSymmetryDepth1HE.png\" />" << std::endl;
23157  if (sub == 4)
23158  htmlFileR << " <img src=\"DrecosignalPositiveDirectionhistD1PhiSymmetryDepth1HF.png\" />" << std::endl;
23159  htmlFileR << "<br>" << std::endl;
23160 
23161  htmlFileR << "<h3> 2.D. D(recosignalvarianceSignalhe) vs phi , different eta, Depth2 </h3>" << std::endl;
23162  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23163  if (sub == 1)
23164  htmlFileR << " <img src=\"DrecosignalPositiveDirectionhistD1PhiSymmetryDepth2HB.png\" />" << std::endl;
23165  if (sub == 2)
23166  htmlFileR << " <img src=\"DrecosignalPositiveDirectionhistD1PhiSymmetryDepth2HE.png\" />" << std::endl;
23167  if (sub == 4)
23168  htmlFileR << " <img src=\"DrecosignalPositiveDirectionhistD1PhiSymmetryDepth2HF.png\" />" << std::endl;
23169  htmlFileR << "<br>" << std::endl;
23170 
23171  if (sub == 1 || sub == 2)
23172  htmlFileR << "<h3> 2E: D(recosignalvarianceSignalhe) vs phi , different eta, Depth3 </h3>" << std::endl;
23173  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23174  if (sub == 1)
23175  htmlFileR << " <img src=\"DrecosignalPositiveDirectionhistD1PhiSymmetryDepth3HB.png\" />" << std::endl;
23176  if (sub == 2)
23177  htmlFileR << " <img src=\"DrecosignalPositiveDirectionhistD1PhiSymmetryDepth3HE.png\" />" << std::endl;
23178  htmlFileR << "<br>" << std::endl;
23179 
23180  if (sub == 1 || sub == 2)
23181  htmlFileR << "<h3> 2F: D(recosignalvarianceSignalhe) vs phi , different eta, Depth4 </h3>" << std::endl;
23182  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23183  if (sub == 1)
23184  htmlFileR << " <img src=\"DrecosignalPositiveDirectionhistD1PhiSymmetryDepth4HB.png\" />" << std::endl;
23185  if (sub == 2)
23186  htmlFileR << " <img src=\"DrecosignalPositiveDirectionhistD1PhiSymmetryDepth4HE.png\" />" << std::endl;
23187  htmlFileR << "<br>" << std::endl;
23188 
23189  if (sub == 2)
23190  htmlFileR << "<h3> 2G: D(recosignalvarianceSignalhe) vs phi , different eta, Depth5 </h3>" << std::endl;
23191  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23192  if (sub == 2)
23193  htmlFileR << " <img src=\"DrecosignalPositiveDirectionhistD1PhiSymmetryDepth5HE.png\" />" << std::endl;
23194  htmlFileR << "<br>" << std::endl;
23195 
23196  if (sub == 2)
23197  htmlFileR << "<h3> 2H: D(recosignalvarianceSignalhe) vs phi , different eta, Depth6 </h3>" << std::endl;
23198  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23199  if (sub == 2)
23200  htmlFileR << " <img src=\"DrecosignalPositiveDirectionhistD1PhiSymmetryDepth6HE.png\" />" << std::endl;
23201  htmlFileR << "<br>" << std::endl;
23202 
23203  if (sub == 2)
23204  htmlFileR << "<h3> 2I: D(recosignalvarianceSignalhe) vs phi , different eta, Depth7 </h3>" << std::endl;
23205  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23206  if (sub == 2)
23207  htmlFileR << " <img src=\"DrecosignalPositiveDirectionhistD1PhiSymmetryDepth7HE.png\" />" << std::endl;
23208  htmlFileR << "<br>" << std::endl;
23209 
23212  htmlFileR << "<h2> 3: Negative direction, R = R_depth_ieta_iphi = E_depth_ieta_iphi/E_depth_ieta </h3>"
23213  << std::endl;
23214 
23216  htmlFileR << "<h3> 3C: R vs phi , different eta, Depth1 </h3>" << std::endl;
23217  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23218  if (sub == 1)
23219  htmlFileR << " <img src=\"RrecosignalNegativeDirectionhistD1PhiSymmetryDepth1HB.png\" />" << std::endl;
23220  if (sub == 2)
23221  htmlFileR << " <img src=\"RrecosignalNegativeDirectionhistD1PhiSymmetryDepth1HE.png\" />" << std::endl;
23222  if (sub == 4)
23223  htmlFileR << " <img src=\"RrecosignalNegativeDirectionhistD1PhiSymmetryDepth1HF.png\" />" << std::endl;
23224  htmlFileR << "<br>" << std::endl;
23225 
23226  htmlFileR << "<h3> 3D: R vs phi , different eta, Depth2 </h3>" << std::endl;
23227  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23228  if (sub == 1)
23229  htmlFileR << " <img src=\"RrecosignalNegativeDirectionhistD1PhiSymmetryDepth2HB.png\" />" << std::endl;
23230  if (sub == 2)
23231  htmlFileR << " <img src=\"RrecosignalNegativeDirectionhistD1PhiSymmetryDepth2HE.png\" />" << std::endl;
23232  if (sub == 4)
23233  htmlFileR << " <img src=\"RrecosignalNegativeDirectionhistD1PhiSymmetryDepth2HF.png\" />" << std::endl;
23234  htmlFileR << "<br>" << std::endl;
23235 
23236  if (sub == 1 || sub == 2)
23237  htmlFileR << "<h3> 3E: R vs phi , different eta, Depth3 </h3>" << std::endl;
23238  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23239  if (sub == 1)
23240  htmlFileR << " <img src=\"RrecosignalNegativeDirectionhistD1PhiSymmetryDepth3HB.png\" />" << std::endl;
23241  if (sub == 2)
23242  htmlFileR << " <img src=\"RrecosignalNegativeDirectionhistD1PhiSymmetryDepth3HE.png\" />" << std::endl;
23243  htmlFileR << "<br>" << std::endl;
23244 
23245  if (sub == 1 || sub == 2)
23246  htmlFileR << "<h3> 3F: R vs phi , different eta, Depth4 </h3>" << std::endl;
23247  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23248  if (sub == 1)
23249  htmlFileR << " <img src=\"RrecosignalNegativeDirectionhistD1PhiSymmetryDepth4HB.png\" />" << std::endl;
23250  if (sub == 2)
23251  htmlFileR << " <img src=\"RrecosignalNegativeDirectionhistD1PhiSymmetryDepth4HE.png\" />" << std::endl;
23252  htmlFileR << "<br>" << std::endl;
23253 
23254  if (sub == 2)
23255  htmlFileR << "<h3> 3G: R vs phi , different eta, Depth5 </h3>" << std::endl;
23256  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23257  if (sub == 2)
23258  htmlFileR << " <img src=\"RrecosignalNegativeDirectionhistD1PhiSymmetryDepth5HE.png\" />" << std::endl;
23259  htmlFileR << "<br>" << std::endl;
23260 
23261  if (sub == 2)
23262  htmlFileR << "<h3> 3H: R vs phi , different eta, Depth6 </h3>" << std::endl;
23263  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23264  if (sub == 2)
23265  htmlFileR << " <img src=\"RrecosignalNegativeDirectionhistD1PhiSymmetryDepth6HE.png\" />" << std::endl;
23266  htmlFileR << "<br>" << std::endl;
23267 
23268  if (sub == 2)
23269  htmlFileR << "<h3> 3I: R vs phi , different eta, Depth7 </h3>" << std::endl;
23270  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23271  if (sub == 2)
23272  htmlFileR << " <img src=\"RrecosignalNegativeDirectionhistD1PhiSymmetryDepth7HE.png\" />" << std::endl;
23273  htmlFileR << "<br>" << std::endl;
23274 
23276  htmlFileR << "<h2> 4: Negative direction, D(recosignalvarianceSignalhe) </h3>" << std::endl;
23278  htmlFileR << "<h3> 4C: D(recosignalvarianceSignalhe) vs phi , different eta, Depth1 </h3>" << std::endl;
23279  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23280  if (sub == 1)
23281  htmlFileR << " <img src=\"DrecosignalNegativeDirectionhistD1PhiSymmetryDepth1HB.png\" />" << std::endl;
23282  if (sub == 2)
23283  htmlFileR << " <img src=\"DrecosignalNegativeDirectionhistD1PhiSymmetryDepth1HE.png\" />" << std::endl;
23284  if (sub == 4)
23285  htmlFileR << " <img src=\"DrecosignalNegativeDirectionhistD1PhiSymmetryDepth1HF.png\" />" << std::endl;
23286  htmlFileR << "<br>" << std::endl;
23287 
23288  htmlFileR << "<h3> 4.D. D(recosignalvarianceSignalhe) vs phi , different eta, Depth2 </h3>" << std::endl;
23289  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23290  if (sub == 1)
23291  htmlFileR << " <img src=\"DrecosignalNegativeDirectionhistD1PhiSymmetryDepth2HB.png\" />" << std::endl;
23292  if (sub == 2)
23293  htmlFileR << " <img src=\"DrecosignalNegativeDirectionhistD1PhiSymmetryDepth2HE.png\" />" << std::endl;
23294  if (sub == 4)
23295  htmlFileR << " <img src=\"DrecosignalNegativeDirectionhistD1PhiSymmetryDepth2HF.png\" />" << std::endl;
23296  htmlFileR << "<br>" << std::endl;
23297 
23298  if (sub == 1 || sub == 2)
23299  htmlFileR << "<h3> 4E: D(recosignalvarianceSignalhe) vs phi , different eta, Depth3 </h3>" << std::endl;
23300  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23301  if (sub == 1)
23302  htmlFileR << " <img src=\"DrecosignalNegativeDirectionhistD1PhiSymmetryDepth3HB.png\" />" << std::endl;
23303  if (sub == 2)
23304  htmlFileR << " <img src=\"DrecosignalNegativeDirectionhistD1PhiSymmetryDepth3HE.png\" />" << std::endl;
23305  htmlFileR << "<br>" << std::endl;
23306 
23307  if (sub == 1 || sub == 2)
23308  htmlFileR << "<h3> 4F: D(recosignalvarianceSignalhe) vs phi , different eta, Depth4 </h3>" << std::endl;
23309  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23310  if (sub == 1)
23311  htmlFileR << " <img src=\"DrecosignalNegativeDirectionhistD1PhiSymmetryDepth4HB.png\" />" << std::endl;
23312  if (sub == 2)
23313  htmlFileR << " <img src=\"DrecosignalNegativeDirectionhistD1PhiSymmetryDepth4HE.png\" />" << std::endl;
23314  htmlFileR << "<br>" << std::endl;
23315 
23316  if (sub == 2)
23317  htmlFileR << "<h3> 4G: D(recosignalvarianceSignalhe) vs phi , different eta, Depth5 </h3>" << std::endl;
23318  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23319  if (sub == 2)
23320  htmlFileR << " <img src=\"DrecosignalNegativeDirectionhistD1PhiSymmetryDepth5HE.png\" />" << std::endl;
23321  htmlFileR << "<br>" << std::endl;
23322 
23323  if (sub == 2)
23324  htmlFileR << "<h3> 4H: D(recosignalvarianceSignalhe) vs phi , different eta, Depth6 </h3>" << std::endl;
23325  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23326  if (sub == 2)
23327  htmlFileR << " <img src=\"DrecosignalNegativeDirectionhistD1PhiSymmetryDepth6HE.png\" />" << std::endl;
23328  htmlFileR << "<br>" << std::endl;
23329 
23330  if (sub == 2)
23331  htmlFileR << "<h3> 4I: D(recosignalvarianceSignalhe) vs phi , different eta, Depth7 </h3>" << std::endl;
23332  // htmlFileR << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23333  if (sub == 2)
23334  htmlFileR << " <img src=\"DrecosignalNegativeDirectionhistD1PhiSymmetryDepth7HE.png\" />" << std::endl;
23335  htmlFileR << "<br>" << std::endl;
23337  htmlFileR.close();
23339  //
23343 
23344  htmlFileN << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
23345  htmlFileN << "<head>" << std::endl;
23346  htmlFileN << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
23347  htmlFileN << "<title> Remote Monitoring Tool </title>" << std::endl;
23348  htmlFileN << "<style type=\"text/css\">" << std::endl;
23349  htmlFileN << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
23350  << std::endl;
23351  htmlFileN << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
23352  htmlFileN << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
23353  "text-align: center;}"
23354  << std::endl;
23355  htmlFileN << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
23356  htmlFileN << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
23357  htmlFileN << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
23358  htmlFileN << "</style>" << std::endl;
23359  htmlFileN << "<body>" << std::endl;
23360 
23362 
23363  if (sub == 1)
23364  htmlFileN << "<h1> RecoNoise Phi-symmetry for Calibration Group, HB, RUN = " << runnumber << " </h1>"
23365  << std::endl;
23366  if (sub == 2)
23367  htmlFileN << "<h1> RecoNoise Phi-symmetry for Calibration Group, HE, RUN = " << runnumber << " </h1>"
23368  << std::endl;
23369  if (sub == 4)
23370  htmlFileN << "<h1> RecoNoise Phi-symmetry for Calibration Group, HF, RUN = " << runnumber << " </h1>"
23371  << std::endl;
23372  htmlFileN << "<br>" << std::endl;
23373 
23374  htmlFileN << "<h2> 1: R = R_depth_ieta_iphi = E_depth_ieta_iphi/E_depth_ieta </h3>" << std::endl;
23375  htmlFileN << "<h3> 1A: eta/phi-plot: R, averaged over depthes </h3>" << std::endl;
23376  // htmlFileN << "<h4> Legend: Bins less "<<Pedest[0][sub]<<" correpond to bad Pedestals </h4>"<< std::endl;
23377  if (sub == 1)
23378  htmlFileN << " <img src=\"RreconoiseGeneralD2PhiSymmetryHB.png\" />" << std::endl;
23379  if (sub == 2)
23380  htmlFileN << " <img src=\"RreconoiseGeneralD2PhiSymmetryHE.png\" />" << std::endl;
23381  if (sub == 4)
23382  htmlFileN << " <img src=\"RreconoiseGeneralD2PhiSymmetryHF.png\" />" << std::endl;
23383  htmlFileN << "<br>" << std::endl;
23384 
23385  htmlFileN << "<h3> 1B: R vs phi , averaged over depthes & eta </h3>" << std::endl;
23386  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23387  if (sub == 1)
23388  htmlFileN << " <img src=\"RreconoiseGeneralD1PhiSymmetryHB.png\" />" << std::endl;
23389  if (sub == 2)
23390  htmlFileN << " <img src=\"RreconoiseGeneralD1PhiSymmetryHE.png\" />" << std::endl;
23391  if (sub == 4)
23392  htmlFileN << " <img src=\"RreconoiseGeneralD1PhiSymmetryHF.png\" />" << std::endl;
23393  htmlFileN << "<br>" << std::endl;
23394 
23396 
23398  htmlFileN << "<h2> Positive direction, R = R_depth_ieta_iphi = E_depth_ieta_iphi/E_depth_ieta </h3>" << std::endl;
23399  htmlFileN << "<h3> 1C: R vs phi , different eta, Depth1 </h3>" << std::endl;
23400  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23401  if (sub == 1)
23402  htmlFileN << " <img src=\"RreconoisePositiveDirectionhistD1PhiSymmetryDepth1HB.png\" />" << std::endl;
23403  if (sub == 2)
23404  htmlFileN << " <img src=\"RreconoisePositiveDirectionhistD1PhiSymmetryDepth1HE.png\" />" << std::endl;
23405  if (sub == 4)
23406  htmlFileN << " <img src=\"RreconoisePositiveDirectionhistD1PhiSymmetryDepth1HF.png\" />" << std::endl;
23407  htmlFileN << "<br>" << std::endl;
23408 
23409  htmlFileN << "<h3> 1D: R vs phi , different eta, Depth2 </h3>" << std::endl;
23410  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23411  if (sub == 1)
23412  htmlFileN << " <img src=\"RreconoisePositiveDirectionhistD1PhiSymmetryDepth2HB.png\" />" << std::endl;
23413  if (sub == 2)
23414  htmlFileN << " <img src=\"RreconoisePositiveDirectionhistD1PhiSymmetryDepth2HE.png\" />" << std::endl;
23415  if (sub == 4)
23416  htmlFileN << " <img src=\"RreconoisePositiveDirectionhistD1PhiSymmetryDepth2HF.png\" />" << std::endl;
23417  htmlFileN << "<br>" << std::endl;
23418 
23419  if (sub == 1 || sub == 2)
23420  htmlFileN << "<h3> 1E: R vs phi , different eta, Depth3 </h3>" << std::endl;
23421  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23422  if (sub == 1)
23423  htmlFileN << " <img src=\"RreconoisePositiveDirectionhistD1PhiSymmetryDepth3HB.png\" />" << std::endl;
23424  if (sub == 2)
23425  htmlFileN << " <img src=\"RreconoisePositiveDirectionhistD1PhiSymmetryDepth3HE.png\" />" << std::endl;
23426  htmlFileN << "<br>" << std::endl;
23427 
23428  if (sub == 1 || sub == 2)
23429  htmlFileN << "<h3> 1F: R vs phi , different eta, Depth4 </h3>" << std::endl;
23430  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23431  if (sub == 1)
23432  htmlFileN << " <img src=\"RreconoisePositiveDirectionhistD1PhiSymmetryDepth4HB.png\" />" << std::endl;
23433  if (sub == 2)
23434  htmlFileN << " <img src=\"RreconoisePositiveDirectionhistD1PhiSymmetryDepth4HE.png\" />" << std::endl;
23435  htmlFileN << "<br>" << std::endl;
23436 
23437  if (sub == 2)
23438  htmlFileN << "<h3> 1G: R vs phi , different eta, Depth5 </h3>" << std::endl;
23439  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23440  if (sub == 2)
23441  htmlFileN << " <img src=\"RreconoisePositiveDirectionhistD1PhiSymmetryDepth5HE.png\" />" << std::endl;
23442  htmlFileN << "<br>" << std::endl;
23443 
23444  if (sub == 2)
23445  htmlFileN << "<h3> 1H: R vs phi , different eta, Depth6 </h3>" << std::endl;
23446  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23447  if (sub == 2)
23448  htmlFileN << " <img src=\"RreconoisePositiveDirectionhistD1PhiSymmetryDepth6HE.png\" />" << std::endl;
23449  htmlFileN << "<br>" << std::endl;
23450 
23451  if (sub == 2)
23452  htmlFileN << "<h3> 1I: R vs phi , different eta, Depth7 </h3>" << std::endl;
23453  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23454  if (sub == 2)
23455  htmlFileN << " <img src=\"RreconoisePositiveDirectionhistD1PhiSymmetryDepth7HE.png\" />" << std::endl;
23456  htmlFileN << "<br>" << std::endl;
23457 
23459  htmlFileN << "<h2> 2: D(reconoisevarianceNoisehe) </h3>" << std::endl;
23460  htmlFileN << "<h3> 2A: eta/phi-plot: D(reconoisevarianceNoisehe), averaged over depthes </h3>" << std::endl;
23461  // htmlFileN << "<h4> Legend: Bins less "<<Pedest[0][sub]<<" correpond to bad Pedestals </h4>"<< std::endl;
23462  if (sub == 1)
23463  htmlFileN << " <img src=\"DreconoiseGeneralD2PhiSymmetryHB.png\" />" << std::endl;
23464  if (sub == 2)
23465  htmlFileN << " <img src=\"DreconoiseGeneralD2PhiSymmetryHE.png\" />" << std::endl;
23466  if (sub == 4)
23467  htmlFileN << " <img src=\"DreconoiseGeneralD2PhiSymmetryHF.png\" />" << std::endl;
23468  htmlFileN << "<br>" << std::endl;
23469 
23470  htmlFileN << "<h3> 2B: D(reconoisevarianceNoisehe) vs phi , averaged over depthes & eta </h3>" << std::endl;
23471  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23472  if (sub == 1)
23473  htmlFileN << " <img src=\"DreconoiseGeneralD1PhiSymmetryHB.png\" />" << std::endl;
23474  if (sub == 2)
23475  htmlFileN << " <img src=\"DreconoiseGeneralD1PhiSymmetryHE.png\" />" << std::endl;
23476  if (sub == 4)
23477  htmlFileN << " <img src=\"DreconoiseGeneralD1PhiSymmetryHF.png\" />" << std::endl;
23478  htmlFileN << "<br>" << std::endl;
23479 
23482  htmlFileN << "<h2> Positive direction, D(reconoisevarianceNoisehe) </h3>" << std::endl;
23483  htmlFileN << "<h3> 2C: D(reconoisevarianceNoisehe) vs phi , different eta, Depth1 </h3>" << std::endl;
23484  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23485  if (sub == 1)
23486  htmlFileN << " <img src=\"DreconoisePositiveDirectionhistD1PhiSymmetryDepth1HB.png\" />" << std::endl;
23487  if (sub == 2)
23488  htmlFileN << " <img src=\"DreconoisePositiveDirectionhistD1PhiSymmetryDepth1HE.png\" />" << std::endl;
23489  if (sub == 4)
23490  htmlFileN << " <img src=\"DreconoisePositiveDirectionhistD1PhiSymmetryDepth1HF.png\" />" << std::endl;
23491  htmlFileN << "<br>" << std::endl;
23492 
23493  htmlFileN << "<h3> 2.D. D(reconoisevarianceNoisehe) vs phi , different eta, Depth2 </h3>" << std::endl;
23494  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23495  if (sub == 1)
23496  htmlFileN << " <img src=\"DreconoisePositiveDirectionhistD1PhiSymmetryDepth2HB.png\" />" << std::endl;
23497  if (sub == 2)
23498  htmlFileN << " <img src=\"DreconoisePositiveDirectionhistD1PhiSymmetryDepth2HE.png\" />" << std::endl;
23499  if (sub == 4)
23500  htmlFileN << " <img src=\"DreconoisePositiveDirectionhistD1PhiSymmetryDepth2HF.png\" />" << std::endl;
23501  htmlFileN << "<br>" << std::endl;
23502 
23503  if (sub == 1 || sub == 2)
23504  htmlFileN << "<h3> 2E: D(reconoisevarianceNoisehe) vs phi , different eta, Depth3 </h3>" << std::endl;
23505  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23506  if (sub == 1)
23507  htmlFileN << " <img src=\"DreconoisePositiveDirectionhistD1PhiSymmetryDepth3HB.png\" />" << std::endl;
23508  if (sub == 2)
23509  htmlFileN << " <img src=\"DreconoisePositiveDirectionhistD1PhiSymmetryDepth3HE.png\" />" << std::endl;
23510  htmlFileN << "<br>" << std::endl;
23511 
23512  if (sub == 1 || sub == 2)
23513  htmlFileN << "<h3> 2F: D(reconoisevarianceNoisehe) vs phi , different eta, Depth4 </h3>" << std::endl;
23514  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23515  if (sub == 1)
23516  htmlFileN << " <img src=\"DreconoisePositiveDirectionhistD1PhiSymmetryDepth4HB.png\" />" << std::endl;
23517  if (sub == 2)
23518  htmlFileN << " <img src=\"DreconoisePositiveDirectionhistD1PhiSymmetryDepth4HE.png\" />" << std::endl;
23519  htmlFileN << "<br>" << std::endl;
23520 
23521  if (sub == 2)
23522  htmlFileN << "<h3> 2G: D(reconoisevarianceNoisehe) vs phi , different eta, Depth5 </h3>" << std::endl;
23523  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23524  if (sub == 2)
23525  htmlFileN << " <img src=\"DreconoisePositiveDirectionhistD1PhiSymmetryDepth5HE.png\" />" << std::endl;
23526  htmlFileN << "<br>" << std::endl;
23527 
23528  if (sub == 2)
23529  htmlFileN << "<h3> 2H: D(reconoisevarianceNoisehe) vs phi , different eta, Depth6 </h3>" << std::endl;
23530  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23531  if (sub == 2)
23532  htmlFileN << " <img src=\"DreconoisePositiveDirectionhistD1PhiSymmetryDepth6HE.png\" />" << std::endl;
23533  htmlFileN << "<br>" << std::endl;
23534 
23535  if (sub == 2)
23536  htmlFileN << "<h3> 2I: D(reconoisevarianceNoisehe) vs phi , different eta, Depth7 </h3>" << std::endl;
23537  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23538  if (sub == 2)
23539  htmlFileN << " <img src=\"DreconoisePositiveDirectionhistD1PhiSymmetryDepth7HE.png\" />" << std::endl;
23540  htmlFileN << "<br>" << std::endl;
23541 
23544  htmlFileN << "<h2> 3: Negative direction, R = R_depth_ieta_iphi = E_depth_ieta_iphi/E_depth_ieta </h3>"
23545  << std::endl;
23546 
23548  htmlFileN << "<h3> 3C: R vs phi , different eta, Depth1 </h3>" << std::endl;
23549  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23550  if (sub == 1)
23551  htmlFileN << " <img src=\"RreconoiseNegativeDirectionhistD1PhiSymmetryDepth1HB.png\" />" << std::endl;
23552  if (sub == 2)
23553  htmlFileN << " <img src=\"RreconoiseNegativeDirectionhistD1PhiSymmetryDepth1HE.png\" />" << std::endl;
23554  if (sub == 4)
23555  htmlFileN << " <img src=\"RreconoiseNegativeDirectionhistD1PhiSymmetryDepth1HF.png\" />" << std::endl;
23556  htmlFileN << "<br>" << std::endl;
23557 
23558  htmlFileN << "<h3> 3D: R vs phi , different eta, Depth2 </h3>" << std::endl;
23559  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23560  if (sub == 1)
23561  htmlFileN << " <img src=\"RreconoiseNegativeDirectionhistD1PhiSymmetryDepth2HB.png\" />" << std::endl;
23562  if (sub == 2)
23563  htmlFileN << " <img src=\"RreconoiseNegativeDirectionhistD1PhiSymmetryDepth2HE.png\" />" << std::endl;
23564  if (sub == 4)
23565  htmlFileN << " <img src=\"RreconoiseNegativeDirectionhistD1PhiSymmetryDepth2HF.png\" />" << std::endl;
23566  htmlFileN << "<br>" << std::endl;
23567 
23568  if (sub == 1 || sub == 2)
23569  htmlFileN << "<h3> 3E: R vs phi , different eta, Depth3 </h3>" << std::endl;
23570  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23571  if (sub == 1)
23572  htmlFileN << " <img src=\"RreconoiseNegativeDirectionhistD1PhiSymmetryDepth3HB.png\" />" << std::endl;
23573  if (sub == 2)
23574  htmlFileN << " <img src=\"RreconoiseNegativeDirectionhistD1PhiSymmetryDepth3HE.png\" />" << std::endl;
23575  htmlFileN << "<br>" << std::endl;
23576 
23577  if (sub == 1 || sub == 2)
23578  htmlFileN << "<h3> 3F: R vs phi , different eta, Depth4 </h3>" << std::endl;
23579  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23580  if (sub == 1)
23581  htmlFileN << " <img src=\"RreconoiseNegativeDirectionhistD1PhiSymmetryDepth4HB.png\" />" << std::endl;
23582  if (sub == 2)
23583  htmlFileN << " <img src=\"RreconoiseNegativeDirectionhistD1PhiSymmetryDepth4HE.png\" />" << std::endl;
23584  htmlFileN << "<br>" << std::endl;
23585 
23586  if (sub == 2)
23587  htmlFileN << "<h3> 3G: R vs phi , different eta, Depth5 </h3>" << std::endl;
23588  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23589  if (sub == 2)
23590  htmlFileN << " <img src=\"RreconoiseNegativeDirectionhistD1PhiSymmetryDepth5HE.png\" />" << std::endl;
23591  htmlFileN << "<br>" << std::endl;
23592 
23593  if (sub == 2)
23594  htmlFileN << "<h3> 3H: R vs phi , different eta, Depth6 </h3>" << std::endl;
23595  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23596  if (sub == 2)
23597  htmlFileN << " <img src=\"RreconoiseNegativeDirectionhistD1PhiSymmetryDepth6HE.png\" />" << std::endl;
23598  htmlFileN << "<br>" << std::endl;
23599 
23600  if (sub == 2)
23601  htmlFileN << "<h3> 3I: R vs phi , different eta, Depth7 </h3>" << std::endl;
23602  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23603  if (sub == 2)
23604  htmlFileN << " <img src=\"RreconoiseNegativeDirectionhistD1PhiSymmetryDepth7HE.png\" />" << std::endl;
23605  htmlFileN << "<br>" << std::endl;
23606 
23608  htmlFileN << "<h2> 4: Negative direction, D(reconoisevarianceNoisehe) </h3>" << std::endl;
23610  htmlFileN << "<h3> 4C: D(reconoisevarianceNoisehe) vs phi , different eta, Depth1 </h3>" << std::endl;
23611  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23612  if (sub == 1)
23613  htmlFileN << " <img src=\"DreconoiseNegativeDirectionhistD1PhiSymmetryDepth1HB.png\" />" << std::endl;
23614  if (sub == 2)
23615  htmlFileN << " <img src=\"DreconoiseNegativeDirectionhistD1PhiSymmetryDepth1HE.png\" />" << std::endl;
23616  if (sub == 4)
23617  htmlFileN << " <img src=\"DreconoiseNegativeDirectionhistD1PhiSymmetryDepth1HF.png\" />" << std::endl;
23618  htmlFileN << "<br>" << std::endl;
23619 
23620  htmlFileN << "<h3> 4.D. D(reconoisevarianceNoisehe) vs phi , different eta, Depth2 </h3>" << std::endl;
23621  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23622  if (sub == 1)
23623  htmlFileN << " <img src=\"DreconoiseNegativeDirectionhistD1PhiSymmetryDepth2HB.png\" />" << std::endl;
23624  if (sub == 2)
23625  htmlFileN << " <img src=\"DreconoiseNegativeDirectionhistD1PhiSymmetryDepth2HE.png\" />" << std::endl;
23626  if (sub == 4)
23627  htmlFileN << " <img src=\"DreconoiseNegativeDirectionhistD1PhiSymmetryDepth2HF.png\" />" << std::endl;
23628  htmlFileN << "<br>" << std::endl;
23629 
23630  if (sub == 1 || sub == 2)
23631  htmlFileN << "<h3> 4E: D(reconoisevarianceNoisehe) vs phi , different eta, Depth3 </h3>" << std::endl;
23632  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23633  if (sub == 1)
23634  htmlFileN << " <img src=\"DreconoiseNegativeDirectionhistD1PhiSymmetryDepth3HB.png\" />" << std::endl;
23635  if (sub == 2)
23636  htmlFileN << " <img src=\"DreconoiseNegativeDirectionhistD1PhiSymmetryDepth3HE.png\" />" << std::endl;
23637  htmlFileN << "<br>" << std::endl;
23638 
23639  if (sub == 1 || sub == 2)
23640  htmlFileN << "<h3> 4F: D(reconoisevarianceNoisehe) vs phi , different eta, Depth4 </h3>" << std::endl;
23641  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23642  if (sub == 1)
23643  htmlFileN << " <img src=\"DreconoiseNegativeDirectionhistD1PhiSymmetryDepth4HB.png\" />" << std::endl;
23644  if (sub == 2)
23645  htmlFileN << " <img src=\"DreconoiseNegativeDirectionhistD1PhiSymmetryDepth4HE.png\" />" << std::endl;
23646  htmlFileN << "<br>" << std::endl;
23647 
23648  if (sub == 2)
23649  htmlFileN << "<h3> 4G: D(reconoisevarianceNoisehe) vs phi , different eta, Depth5 </h3>" << std::endl;
23650  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23651  if (sub == 2)
23652  htmlFileN << " <img src=\"DreconoiseNegativeDirectionhistD1PhiSymmetryDepth5HE.png\" />" << std::endl;
23653  htmlFileN << "<br>" << std::endl;
23654 
23655  if (sub == 2)
23656  htmlFileN << "<h3> 4H: D(reconoisevarianceNoisehe) vs phi , different eta, Depth6 </h3>" << std::endl;
23657  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23658  if (sub == 2)
23659  htmlFileN << " <img src=\"DreconoiseNegativeDirectionhistD1PhiSymmetryDepth6HE.png\" />" << std::endl;
23660  htmlFileN << "<br>" << std::endl;
23661 
23662  if (sub == 2)
23663  htmlFileN << "<h3> 4I: D(reconoisevarianceNoisehe) vs phi , different eta, Depth7 </h3>" << std::endl;
23664  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23665  if (sub == 2)
23666  htmlFileN << " <img src=\"DreconoiseNegativeDirectionhistD1PhiSymmetryDepth7HE.png\" />" << std::endl;
23667  htmlFileN << "<br>" << std::endl;
23669 
23671 
23672  if (sub == 1)
23673  htmlFileN << "<h1> Only for Noise RecHits these lines below, HB, RUN = " << runnumber << " </h1>" << std::endl;
23674  if (sub == 2)
23675  htmlFileN << "<h1> Only for Noise RecHits these lines below, HE, RUN = " << runnumber << " </h1>" << std::endl;
23676  if (sub == 4)
23677  htmlFileN << "<h1> Only for Noise RecHits these lines below, HF, RUN = " << runnumber << " </h1>" << std::endl;
23678  htmlFileN << "<br>" << std::endl;
23679 
23680  htmlFileN << "<h2> 5: DIF = DIF_depth_ieta_iphi = E_depth_ieta_iphi - E_depth_ieta </h3>" << std::endl;
23681  htmlFileN << "<h3> 5A: eta/phi-plot: DIF, averaged over depthes </h3>" << std::endl;
23682  // htmlFileN << "<h4> Legend: Bins less "<<Pedest[0][sub]<<" correpond to bad Pedestals </h4>"<< std::endl;
23683  if (sub == 1)
23684  htmlFileN << " <img src=\"DIFreconoiseGeneralD2PhiSymmetryHB.png\" />" << std::endl;
23685  if (sub == 2)
23686  htmlFileN << " <img src=\"DIFreconoiseGeneralD2PhiSymmetryHE.png\" />" << std::endl;
23687  if (sub == 4)
23688  htmlFileN << " <img src=\"DIFreconoiseGeneralD2PhiSymmetryHF.png\" />" << std::endl;
23689  htmlFileN << "<br>" << std::endl;
23690 
23691  htmlFileN << "<h3> 5B: DIF vs phi , averaged over depthes & eta </h3>" << std::endl;
23692  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23693  if (sub == 1)
23694  htmlFileN << " <img src=\"DIFreconoiseGeneralD1PhiSymmetryHB.png\" />" << std::endl;
23695  if (sub == 2)
23696  htmlFileN << " <img src=\"DIFreconoiseGeneralD1PhiSymmetryHE.png\" />" << std::endl;
23697  if (sub == 4)
23698  htmlFileN << " <img src=\"DIFreconoiseGeneralD1PhiSymmetryHF.png\" />" << std::endl;
23699  htmlFileN << "<br>" << std::endl;
23700 
23702 
23704  htmlFileN << "<h2> Positive direction, DIF = DIF_depth_ieta_iphi = E_depth_ieta_iphi - E_depth_ieta </h3>"
23705  << std::endl;
23706  htmlFileN << "<h3> 5C: DIF vs phi , different eta, Depth1 </h3>" << std::endl;
23707  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23708  if (sub == 1)
23709  htmlFileN << " <img src=\"DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth1HB.png\" />" << std::endl;
23710  if (sub == 2)
23711  htmlFileN << " <img src=\"DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth1HE.png\" />" << std::endl;
23712  if (sub == 4)
23713  htmlFileN << " <img src=\"DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth1HF.png\" />" << std::endl;
23714  htmlFileN << "<br>" << std::endl;
23715 
23716  htmlFileN << "<h3> 5D: DIF vs phi , different eta, Depth2 </h3>" << std::endl;
23717  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23718  if (sub == 1)
23719  htmlFileN << " <img src=\"DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth2HB.png\" />" << std::endl;
23720  if (sub == 2)
23721  htmlFileN << " <img src=\"DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth2HE.png\" />" << std::endl;
23722  if (sub == 4)
23723  htmlFileN << " <img src=\"DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth2HF.png\" />" << std::endl;
23724  htmlFileN << "<br>" << std::endl;
23725 
23726  if (sub == 1 || sub == 2)
23727  htmlFileN << "<h3> 1E: DIF vs phi , different eta, Depth3 </h3>" << std::endl;
23728  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23729  if (sub == 1)
23730  htmlFileN << " <img src=\"DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth3HB.png\" />" << std::endl;
23731  if (sub == 2)
23732  htmlFileN << " <img src=\"DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth3HE.png\" />" << std::endl;
23733  htmlFileN << "<br>" << std::endl;
23734 
23735  if (sub == 1 || sub == 2)
23736  htmlFileN << "<h3> 5F: DIF vs phi , different eta, Depth4 </h3>" << std::endl;
23737  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23738  if (sub == 1)
23739  htmlFileN << " <img src=\"DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth4HB.png\" />" << std::endl;
23740  if (sub == 2)
23741  htmlFileN << " <img src=\"DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth4HE.png\" />" << std::endl;
23742  htmlFileN << "<br>" << std::endl;
23743 
23744  if (sub == 2)
23745  htmlFileN << "<h3> 5G: DIF vs phi , different eta, Depth5 </h3>" << std::endl;
23746  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23747  if (sub == 2)
23748  htmlFileN << " <img src=\"DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth5HE.png\" />" << std::endl;
23749  htmlFileN << "<br>" << std::endl;
23750 
23751  if (sub == 2)
23752  htmlFileN << "<h3> 5H: DIF vs phi , different eta, Depth6 </h3>" << std::endl;
23753  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23754  if (sub == 2)
23755  htmlFileN << " <img src=\"DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth6HE.png\" />" << std::endl;
23756  htmlFileN << "<br>" << std::endl;
23757 
23758  if (sub == 2)
23759  htmlFileN << "<h3> 5I: DIF vs phi , different eta, Depth7 </h3>" << std::endl;
23760  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23761  if (sub == 2)
23762  htmlFileN << " <img src=\"DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth7HE.png\" />" << std::endl;
23763  htmlFileN << "<br>" << std::endl;
23764 
23766 
23768  htmlFileN << "<h2> Negative direction, DIF = DIF_depth_ieta_iphi = E_depth_ieta_iphi - E_depth_ieta </h3>"
23769  << std::endl;
23770  htmlFileN << "<h3> 5C: DIF vs phi , different eta, Depth1 </h3>" << std::endl;
23771  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23772  if (sub == 1)
23773  htmlFileN << " <img src=\"DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth1HB.png\" />" << std::endl;
23774  if (sub == 2)
23775  htmlFileN << " <img src=\"DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth1HE.png\" />" << std::endl;
23776  if (sub == 4)
23777  htmlFileN << " <img src=\"DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth1HF.png\" />" << std::endl;
23778  htmlFileN << "<br>" << std::endl;
23779 
23780  htmlFileN << "<h3> 5D: DIF vs phi , different eta, Depth2 </h3>" << std::endl;
23781  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23782  if (sub == 1)
23783  htmlFileN << " <img src=\"DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth2HB.png\" />" << std::endl;
23784  if (sub == 2)
23785  htmlFileN << " <img src=\"DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth2HE.png\" />" << std::endl;
23786  if (sub == 4)
23787  htmlFileN << " <img src=\"DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth2HF.png\" />" << std::endl;
23788  htmlFileN << "<br>" << std::endl;
23789 
23790  if (sub == 1 || sub == 2)
23791  htmlFileN << "<h3> 5E: DIF vs phi , different eta, Depth3 </h3>" << std::endl;
23792  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23793  if (sub == 1)
23794  htmlFileN << " <img src=\"DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth3HB.png\" />" << std::endl;
23795  if (sub == 2)
23796  htmlFileN << " <img src=\"DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth3HE.png\" />" << std::endl;
23797  htmlFileN << "<br>" << std::endl;
23798 
23799  if (sub == 1 || sub == 2)
23800  htmlFileN << "<h3> 5F: DIF vs phi , different eta, Depth4 </h3>" << std::endl;
23801  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23802  if (sub == 1)
23803  htmlFileN << " <img src=\"DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth4HB.png\" />" << std::endl;
23804  if (sub == 2)
23805  htmlFileN << " <img src=\"DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth4HE.png\" />" << std::endl;
23806  htmlFileN << "<br>" << std::endl;
23807 
23808  if (sub == 2)
23809  htmlFileN << "<h3> 5G: DIF vs phi , different eta, Depth5 </h3>" << std::endl;
23810  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23811  if (sub == 2)
23812  htmlFileN << " <img src=\"DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth5HE.png\" />" << std::endl;
23813  htmlFileN << "<br>" << std::endl;
23814 
23815  if (sub == 2)
23816  htmlFileN << "<h3> 5H: DIF vs phi , different eta, Depth6 </h3>" << std::endl;
23817  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23818  if (sub == 2)
23819  htmlFileN << " <img src=\"DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth6HE.png\" />" << std::endl;
23820  htmlFileN << "<br>" << std::endl;
23821 
23822  if (sub == 2)
23823  htmlFileN << "<h3> 5I: DIF vs phi , different eta, Depth7 </h3>" << std::endl;
23824  // htmlFileN << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
23825  if (sub == 2)
23826  htmlFileN << " <img src=\"DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth7HE.png\" />" << std::endl;
23827  htmlFileN << "<br>" << std::endl;
23828 
23830 
23831  //
23832  //
23833  htmlFileN.close();
23834 
23837 
23838  //
23839  //
23840  } // end sub //for (int sub=1;sub<=4;sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
23841 
23842  //======================================================================
23843 
23844  std::cout << "********" << std::endl;
23845  std::cout << "************ Start creating subdet html pages: - rather long time needed, waiting please"
23846  << std::endl;
23847  //======================================================================
23848  // Creating subdet html pages:
23849 
23850  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
23851  ofstream htmlFile;
23852  if (sub == 1)
23853  htmlFile.open("HB.html");
23854  if (sub == 2)
23855  htmlFile.open("HE.html");
23856  if (sub == 3)
23857  htmlFile.open("HO.html");
23858  if (sub == 4)
23859  htmlFile.open("HF.html");
23860 
23861  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
23862  htmlFile << "<head>" << std::endl;
23863  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
23864  htmlFile << "<title> Remote Monitoring Tool </title>" << std::endl;
23865  htmlFile << "<style type=\"text/css\">" << std::endl;
23866  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
23867  << std::endl;
23868  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
23869  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
23870  "text-align: center;}"
23871  << std::endl;
23872  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
23873  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
23874  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
23875  htmlFile << " td.s5 { font-family: arial, arial ce, helvetica; background-color: #FF00FF; }" << std::endl;
23876  htmlFile << " td.s6 { font-family: arial, arial ce, helvetica; background-color: #9ACD32; }" << std::endl;
23877  htmlFile << " td.s7 { font-family: arial, arial ce, helvetica; background-color: #32CD32; }" << std::endl;
23878  htmlFile << " td.s8 { font-family: arial, arial ce, helvetica; background-color: #00FFFF; }" << std::endl;
23879  htmlFile << " td.s9 { font-family: arial, arial ce, helvetica; background-color: #FFE4E1; }" << std::endl;
23880  htmlFile << " td.s10 { font-family: arial, arial ce, helvetica; background-color: #A0522D; }" << std::endl;
23881  htmlFile << " td.s11 { font-family: arial, arial ce, helvetica; background-color: #1E90FF; }" << std::endl;
23882  htmlFile << " td.s12 { font-family: arial, arial ce, helvetica; background-color: #00BFFF; }" << std::endl;
23883  htmlFile << " td.s13 { font-family: arial, arial ce, helvetica; background-color: #FFFF00; }" << std::endl;
23884  htmlFile << " td.s14 { font-family: arial, arial ce, helvetica; background-color: #B8860B; }" << std::endl;
23885  htmlFile << "</style>" << std::endl;
23886  htmlFile << "<body>" << std::endl;
23887  if (sub == 1)
23888  htmlFile << "<h1> HCAL BARREL, RUN = " << runnumber << " </h1>" << std::endl;
23889  if (sub == 2)
23890  htmlFile << "<h1> HCAL ENDCAP, RUN = " << runnumber << " </h1>" << std::endl;
23891  if (sub == 3)
23892  htmlFile << "<h1> HCAL OUTER, RUN = " << runnumber << " </h1>" << std::endl;
23893  if (sub == 4)
23894  htmlFile << "<h1> HCAL FORWARD, RUN = " << runnumber << " </h1>" << std::endl;
23895  htmlFile << "<br>" << std::endl;
23896  if (sub == 1)
23897  htmlFile << "<h2> 1. Analysis results for HB</h2>" << std::endl;
23898  if (sub == 2)
23899  htmlFile << "<h2> 1. Analysis results for HE</h2>" << std::endl;
23900  if (sub == 3)
23901  htmlFile << "<h2> 1. Analysis results for HO</h2>" << std::endl;
23902  if (sub == 4)
23903  htmlFile << "<h2> 1. Analysis results for HF</h2>" << std::endl;
23904  htmlFile << "<table width=\"600\">" << std::endl;
23905  htmlFile << "<tr>" << std::endl;
23906 
23907  if (sub == 1) {
23908  htmlFile << " <td><a href=\"HB_Tile.html\">Megatile Channels</a></td>" << std::endl;
23909  htmlFile << " <td><a href=\"HB_Calib.html\">Calibration Channels</a></td>" << std::endl;
23910  htmlFile << " <td><a href=\"HB_Drift.html\">Gain Stability</a></td>" << std::endl;
23911  htmlFile << " <td><a href=\"HB_Pedestals.html\">Pedestals</a></td>" << std::endl;
23912  htmlFile << " <td><a href=\"HB_Shapes.html\">ADC Shapes</a></td>" << std::endl;
23913  htmlFile << " <td><a href=\"HB_PhiSymmetryDigi.html\">Phi-symmetryDigi</a></td>" << std::endl;
23914  htmlFile << " <td><a href=\"HB_PhiSymmetryRecoSignal.html\">Phi-symmetryRecoSignal</a></td>" << std::endl;
23915  htmlFile << " <td><a href=\"HB_PhiSymmetryRecoNoise.html\">Phi-symmetryRecoNoise</a></td>" << std::endl;
23916 
23917  /*
23918  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HB_Tile.html\">Megatile Channels</a></td>"<< std::endl;
23919  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HB_Calib.html\">Calibration Channels</a></td>"<< std::endl;
23920  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HB_Drift.html\">Gain Stability</a></td>"<< std::endl;
23921  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HB_Pedestals.html\">Pedestals</a></td>"<< std::endl;
23922  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HB_Shapes.html\">ADC Shapes</a></td>"<< std::endl;
23923  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HB_PhiSymmetryDigi.html\">Phi-SymmetryDigi</a></td>"<< std::endl;
23924  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HB_PhiSymmetryRecoSignal.html\">Phi-SymmetryRecoSignal</a></td>"<< std::endl;
23925  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HB_PhiSymmetryRecoNoise.html\">Phi-SymmetryRecoNoise</a></td>"<< std::endl;
23926 */
23927  }
23928  if (sub == 2) {
23929  htmlFile << " <td><a href=\"HE_Tile.html\">Megatile Channels</a></td>" << std::endl;
23930  htmlFile << " <td><a href=\"HE_Calib.html\">Calibration Channels</a></td>" << std::endl;
23931  htmlFile << " <td><a href=\"HE_Drift.html\">Gain Stability</a></td>" << std::endl;
23932  htmlFile << " <td><a href=\"HE_Pedestals.html\">Pedestals</a></td>" << std::endl;
23933  htmlFile << " <td><a href=\"HE_Shapes.html\">ADC Shapes</a></td>" << std::endl;
23934  htmlFile << " <td><a href=\"HE_PhiSymmetryDigi.html\">Phi-symmetryDigi</a></td>" << std::endl;
23935  htmlFile << " <td><a href=\"HE_PhiSymmetryRecoSignal.html\">Phi-symmetryRecoSignal</a></td>" << std::endl;
23936  htmlFile << " <td><a href=\"HE_PhiSymmetryRecoNoise.html\">Phi-symmetryRecoNoise</a></td>" << std::endl;
23937 
23938  /*
23939  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HE_Tile.html\">Megatile Channels</a></td>"<< std::endl;
23940  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HE_Calib.html\">Calibration Channels</a></td>"<< std::endl;
23941  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HE_Drift.html\">Gain Stability</a></td>"<< std::endl;
23942  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HE_Pedestals.html\">Pedestals</a></td>"<< std::endl;
23943  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HE_Shapes.html\">ADC Shapes</a></td>"<< std::endl;
23944  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HE_PhiSymmetryDigi.html\">Phi-symmetryDigi</a></td>"<< std::endl;
23945  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HE_PhiSymmetryRecoSignal.html\">Phi-symmetryRecoSignal</a></td>"<< std::endl;
23946  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HE_PhiSymmetryRecoNoise.html\">Phi-symmetryRecoNoise</a></td>"<< std::endl;
23947  */
23948  }
23949  if (sub == 3) {
23950  htmlFile << " <td><a href=\"HO_Tile.html\">Megatile Channels</a></td>" << std::endl;
23951  htmlFile << " <td><a href=\"HO_Calib.html\">Calibration Channels</a></td>" << std::endl;
23952  htmlFile << " <td><a href=\"HO_Drift.html\">Gain Stability</a></td>" << std::endl;
23953  htmlFile << " <td><a href=\"HO_Pedestals.html\">Pedestals</a></td>" << std::endl;
23954  htmlFile << " <td><a href=\"HO_Shapes.html\">ADC Shapes</a></td>" << std::endl;
23955 
23956  /*
23957  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HO_Tile.html\">Megatile Channels</a></td>"<< std::endl;
23958  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HO_Calib.html\">Calibration Channels</a></td>"<< std::endl;
23959  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HO_Drift.html\">Gain Stability</a></td>"<< std::endl;
23960  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HO_Pedestals.html\">Pedestals</a></td>"<< std::endl;
23961  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HO_Shapes.html\">ADC Shapes</a></td>"<< std::endl;
23962  */
23963  }
23964 
23965  if (sub == 4) {
23966  htmlFile << " <td><a href=\"HF_Tile.html\">Megatile Channels</a></td>" << std::endl;
23967  htmlFile << " <td><a href=\"HF_Calib.html\">Calibration Channels</a></td>" << std::endl;
23968  htmlFile << " <td><a href=\"HF_Drift.html\">Gain Stability</a></td>" << std::endl;
23969  htmlFile << " <td><a href=\"HF_Pedestals.html\">Pedestals</a></td>" << std::endl;
23970  htmlFile << " <td><a href=\"HF_Shapes.html\">ADC Shapes</a></td>" << std::endl;
23971  htmlFile << " <td><a href=\"HF_PhiSymmetryDigi.html\">Phi-symmetryDigi</a></td>" << std::endl;
23972  htmlFile << " <td><a href=\"HF_PhiSymmetryRecoSignal.html\">Phi-symmetryRecoSignal</a></td>" << std::endl;
23973  htmlFile << " <td><a href=\"HF_PhiSymmetryRecoNoise.html\">Phi-symmetryRecoNoise</a></td>" << std::endl;
23974 
23975  /*
23976  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HF_Tile.html\">Megatile Channels</a></td>"<< std::endl;
23977  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HF_Calib.html\">Calibration Channels</a></td>"<< std::endl;
23978  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HF_Drift.html\">Gain Stability</a></td>"<< std::endl;
23979  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HF_Pedestals.html\">Pedestals</a></td>"<< std::endl;
23980  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HF_Shapes.html\">ADC Shapes</a></td>"<< std::endl;
23981  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HF_PhiSymmetryDigi.html\">Phi-symmetryDigi</a></td>"<< std::endl;
23982  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HF_PhiSymmetryRecoSignal.html\">Phi-symmetryRecoSignal</a></td>"<< std::endl;
23983  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HF_PhiSymmetryRecoNoise.html\">Phi-symmetryRecoNoise</a></td>"<< std::endl;
23984  */
23985  }
23986 
23987  htmlFile << "</tr>" << std::endl;
23988  htmlFile << "</table>" << std::endl;
23989  htmlFile << "<br>" << std::endl;
23990  if (sub == 1)
23991  htmlFile << "<h2> 2.Status HB over all criteria </h2>" << std::endl;
23992  if (sub == 2)
23993  htmlFile << "<h2> 2.Status HE over all criteria </h2>" << std::endl;
23994  if (sub == 3)
23995  htmlFile << "<h2> 2.Status HO over all criteria </h2>" << std::endl;
23996  if (sub == 4)
23997  htmlFile << "<h2> 2.Status HF over all criteria </h2>" << std::endl;
23998  htmlFile << "<h3> 2.A.Channel map for each Depth </h3>" << std::endl;
23999  htmlFile << "<h4> Channel legend: green - good, red - bad (rate of failures at least 0.1), yellow - at least 2% "
24000  "gain drift, white - not applicable or out of range </h4>"
24001  << std::endl;
24002  if (sub == 1)
24003  htmlFile << " <img src=\"MAPHB.png\" />" << std::endl;
24004  if (sub == 2)
24005  htmlFile << " <img src=\"MAPHE.png\" />" << std::endl;
24006  if (sub == 3)
24007  htmlFile << " <img src=\"MAPHO.png\" />" << std::endl;
24008  if (sub == 4)
24009  htmlFile << " <img src=\"MAPHF.png\" />" << std::endl;
24010  htmlFile << "<br>" << std::endl;
24011 
24012  htmlFile << "<h3> 2.B.List of Bad channels (rate > 0.1) and its rates for each RMT criteria (for GS - %) </h3>"
24013  << std::endl;
24014 
24015  // htmlFile << " <td><a href=\"HELP.html\"> Description of criteria for bad channel selection</a></td>"<< std::endl;
24016  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_" << runnumber
24017  << "/HELP.html\"> Description of criteria for bad channel selection</a></td>" << std::endl;
24018 
24019  htmlFile << "<table>" << std::endl;
24020  htmlFile << "<tr>";
24021  htmlFile << "<td class=\"s4\" align=\"center\">#</td>" << std::endl;
24022  htmlFile << "<td class=\"s1\" align=\"center\">ETA</td>" << std::endl;
24023  htmlFile << "<td class=\"s1\" align=\"center\">PHI</td>" << std::endl;
24024  htmlFile << "<td class=\"s1\" align=\"center\">DEPTH</td>" << std::endl;
24025  htmlFile << "<td class=\"s1\" align=\"center\">RBX</td>" << std::endl;
24026  htmlFile << "<td class=\"s1\" align=\"center\">RM</td>" << std::endl;
24027  htmlFile << "<td class=\"s1\" align=\"center\">PIXEL</td>" << std::endl;
24028  htmlFile << "<td class=\"s1\" align=\"center\">RM_FIBER</td>" << std::endl;
24029  htmlFile << "<td class=\"s1\" align=\"center\">FIBER_CH</td>" << std::endl;
24030  htmlFile << "<td class=\"s1\" align=\"center\">QIE</td>" << std::endl;
24031  htmlFile << "<td class=\"s1\" align=\"center\">ADC</td>" << std::endl;
24032  htmlFile << "<td class=\"s1\" align=\"center\">CRATE</td>" << std::endl;
24033  htmlFile << "<td class=\"s1\" align=\"center\">DCC</td>" << std::endl;
24034  htmlFile << "<td class=\"s1\" align=\"center\">SPIGOT</td>" << std::endl;
24035  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FIBER</td>" << std::endl;
24036  htmlFile << "<td class=\"s1\" align=\"center\">HTR_SLOT</td>" << std::endl;
24037  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FPGA</td>" << std::endl;
24038  htmlFile << "<td class=\"s5\" align=\"center\">Cm</td>" << std::endl;
24039  htmlFile << "<td class=\"s5\" align=\"center\">Am</td>" << std::endl;
24040  htmlFile << "<td class=\"s5\" align=\"center\">Wm</td>" << std::endl;
24041  htmlFile << "<td class=\"s5\" align=\"center\">Rm</td>" << std::endl;
24042  htmlFile << "<td class=\"s5\" align=\"center\">TNm</td>" << std::endl;
24043  htmlFile << "<td class=\"s5\" align=\"center\">TXm</td>" << std::endl;
24044  htmlFile << "<td class=\"s9\" align=\"center\">GS (%)</td>" << std::endl;
24045  htmlFile << "<td class=\"s4\" align=\"center\">Pm</td>" << std::endl;
24046  htmlFile << "<td class=\"s4\" align=\"center\">pWm</td>" << std::endl;
24047  htmlFile << "<td class=\"s8\" align=\"center\">Cc</td>" << std::endl;
24048  htmlFile << "<td class=\"s8\" align=\"center\">Ac</td>" << std::endl;
24049  htmlFile << "<td class=\"s8\" align=\"center\">Wc</td>" << std::endl;
24050  htmlFile << "<td class=\"s8\" align=\"center\">Rc</td>" << std::endl;
24051  htmlFile << "<td class=\"s8\" align=\"center\">TNc</td>" << std::endl;
24052  htmlFile << "<td class=\"s8\" align=\"center\">TXc</td>" << std::endl;
24053 
24054  htmlFile << "</tr>" << std::endl;
24055 
24056  for (int i = 1; i <= NBad; i++) {
24057  if ((ind % 2) == 1) {
24058  raw_class = "<td class=\"s2\" align=\"center\">";
24059  raw_class1 = "<td class=\"s6\" align=\"center\">";
24060  raw_class2 = "<td class=\"s11\" align=\"center\">";
24061  raw_class3 = "<td class=\"s13\" align=\"center\">";
24062 
24063  } else {
24064  raw_class = "<td class=\"s3\" align=\"center\">";
24065  raw_class1 = "<td class=\"s7\" align=\"center\">";
24066  raw_class2 = "<td class=\"s12\" align=\"center\">";
24067  raw_class3 = "<td class=\"s14\" align=\"center\">";
24068  }
24069  const CellDB db;
24070  CellDB ce;
24071  if ((ce.size() >= 1) && (Sub[2][i] == sub)) {
24072  if (Sub[2][i] == 1) {
24073  ce = db.find("subdet", "HB").find("Eta", Eta[2][i]).find("Phi", Phi[2][i]).find("Depth", Depth[2][i]);
24074  if (ce.size() == 0) {
24075  // cout<<"Error: No such HB, Eta="<< Eta[2][i] <<", Phi="<< Phi[2][i] <<", Depth="<< Depth[2][i] <<" in database"<<endl;
24076  continue;
24077  } else if (ce.size() > 1) {
24078  cout << "Warning: More than one line correspond to such HB, Eta=" << Eta[2][i] << ", Phi=" << Phi[2][i]
24079  << ", Depth=" << Depth[2][i] << " in database" << endl;
24080  }
24081  }
24082  if (Sub[2][i] == 2) {
24083  ce = db.find("subdet", "HE").find("Eta", Eta[2][i]).find("Phi", Phi[2][i]).find("Depth", Depth[2][i]);
24084  if (ce.size() == 0) {
24085  // cout<<"Error: No such HE, Eta="<< Eta[2][i] <<", Phi="<< Phi[2][i] <<", Depth="<< Depth[2][i] <<" in database"<<endl;
24086  continue;
24087  } else if (ce.size() > 1) {
24088  cout << "Warning: More than one line correspond to such HE, Eta=" << Eta[2][i] << ", Phi=" << Phi[2][i]
24089  << ", Depth=" << Depth[2][i] << " in database" << endl;
24090  }
24091  }
24092  if (Sub[2][i] == 3) {
24093  ce = db.find("subdet", "HO").find("Eta", Eta[2][i]).find("Phi", Phi[2][i]).find("Depth", Depth[2][i]);
24094  if (ce.size() == 0) {
24095  // cout<<"Error: No such HO, Eta="<< Eta[2][i] <<", Phi="<< Phi[2][i] <<", Depth="<< Depth[2][i] <<" in database"<<endl;
24096  continue;
24097  } else if (ce.size() > 1) {
24098  cout << "Warning: More than one line correspond to such HO, Eta=" << Eta[2][i] << ", Phi=" << Phi[2][i]
24099  << ", Depth=" << Depth[2][i] << " in database" << endl;
24100  }
24101  }
24102  if (Sub[2][i] == 4) {
24103  ce = db.find("subdet", "HF").find("Eta", Eta[2][i]).find("Phi", Phi[2][i]).find("Depth", Depth[2][i]);
24104  if (ce.size() == 0) {
24105  // cout<<"Error: No such HF, Eta="<< Eta[2][i] <<", Phi="<< Phi[2][i] <<", Depth="<< Depth[2][i] <<" in database"<<endl;
24106  continue;
24107  } else if (ce.size() > 1) {
24108  cout << "Warning: More than one line correspond to such HF, Eta=" << Eta[2][i] << ", Phi=" << Phi[2][i]
24109  << ", Depth=" << Depth[2][i] << " in database" << endl;
24110  }
24111  }
24112  htmlFile << "<tr>" << std::endl;
24113  htmlFile << "<td class=\"s4\" align=\"center\">" << ind + 1 << "</td>" << std::endl;
24114  htmlFile << raw_class << Eta[2][i] << "</td>" << std::endl;
24115  htmlFile << raw_class << Phi[2][i] << "</td>" << std::endl;
24116  htmlFile << raw_class << Depth[2][i] << "</td>" << std::endl;
24117  htmlFile << raw_class << ce[0].RBX << "</td>" << std::endl;
24118  htmlFile << raw_class << ce[0].RM << "</td>" << std::endl;
24119  htmlFile << raw_class << ce[0].Pixel << "</td>" << std::endl;
24120  htmlFile << raw_class << ce[0].RMfiber << "</td>" << std::endl;
24121  htmlFile << raw_class << ce[0].FiberCh << "</td>" << std::endl;
24122  htmlFile << raw_class << ce[0].QIE << "</td>" << std::endl;
24123  htmlFile << raw_class << ce[0].ADC << "</td>" << std::endl;
24124  htmlFile << raw_class << ce[0].VMECardID << "</td>" << std::endl;
24125  htmlFile << raw_class << ce[0].dccID << "</td>" << std::endl;
24126  htmlFile << raw_class << ce[0].Spigot << "</td>" << std::endl;
24127  htmlFile << raw_class << ce[0].FiberIndex << "</td>" << std::endl;
24128  htmlFile << raw_class << ce[0].HtrSlot << "</td>" << std::endl;
24129  htmlFile << raw_class << ce[0].HtrTB << "</td>" << std::endl;
24130  htmlFile << raw_class1 << Map_Ampl[1][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
24131  << "</td>" << std::endl;
24132  htmlFile << raw_class1 << Map_Ampl[2][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
24133  << "</td>" << std::endl;
24134  htmlFile << raw_class1 << Map_Ampl[3][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
24135  << "</td>" << std::endl;
24136  htmlFile << raw_class1 << Map_Ampl[4][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
24137  << "</td>" << std::endl;
24138  htmlFile << raw_class1 << Map_Ampl[5][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
24139  << "</td>" << std::endl;
24140  htmlFile << raw_class1 << Map_Ampl[6][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
24141  << "</td>" << std::endl;
24142  htmlFile << raw_class3 << Map_Ampl[21][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
24143  << "</td>" << std::endl;
24144  htmlFile << raw_class << Map_Ampl[31][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
24145  << "</td>" << std::endl;
24146  htmlFile << raw_class << Map_Ampl[32][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
24147  << "</td>" << std::endl;
24148  htmlFile << raw_class2 << Map_Ampl[11][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
24149  << "</td>" << std::endl;
24150  htmlFile << raw_class2 << Map_Ampl[12][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
24151  << "</td>" << std::endl;
24152  htmlFile << raw_class2 << Map_Ampl[13][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
24153  << "</td>" << std::endl;
24154  htmlFile << raw_class2 << Map_Ampl[14][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
24155  << "</td>" << std::endl;
24156  htmlFile << raw_class2 << Map_Ampl[15][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
24157  << "</td>" << std::endl;
24158  htmlFile << raw_class2 << Map_Ampl[16][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
24159  << "</td>" << std::endl;
24160  htmlFile << "</tr>" << std::endl;
24161 
24162  ind += 1;
24163  }
24164  }
24165  htmlFile << "</table>" << std::endl;
24166  htmlFile << "<br>" << std::endl;
24167 
24168  htmlFile << "<h3> 2.C.List of Gain unstable channels and its value in % (for other criterias - rate)</h3>"
24169  << std::endl;
24170  htmlFile << "<table>" << std::endl;
24171  htmlFile << "<tr>";
24172  htmlFile << "<td class=\"s4\" align=\"center\">#</td>" << std::endl;
24173  htmlFile << "<td class=\"s1\" align=\"center\">ETA</td>" << std::endl;
24174  htmlFile << "<td class=\"s1\" align=\"center\">PHI</td>" << std::endl;
24175  htmlFile << "<td class=\"s1\" align=\"center\">DEPTH</td>" << std::endl;
24176  htmlFile << "<td class=\"s1\" align=\"center\">RBX</td>" << std::endl;
24177  htmlFile << "<td class=\"s1\" align=\"center\">RM</td>" << std::endl;
24178  htmlFile << "<td class=\"s1\" align=\"center\">PIXEL</td>" << std::endl;
24179  htmlFile << "<td class=\"s1\" align=\"center\">RM_FIBER</td>" << std::endl;
24180  htmlFile << "<td class=\"s1\" align=\"center\">FIBER_CH</td>" << std::endl;
24181  htmlFile << "<td class=\"s1\" align=\"center\">QIE</td>" << std::endl;
24182  htmlFile << "<td class=\"s1\" align=\"center\">ADC</td>" << std::endl;
24183  htmlFile << "<td class=\"s1\" align=\"center\">CRATE</td>" << std::endl;
24184  htmlFile << "<td class=\"s1\" align=\"center\">DCC</td>" << std::endl;
24185  htmlFile << "<td class=\"s1\" align=\"center\">SPIGOT</td>" << std::endl;
24186  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FIBER</td>" << std::endl;
24187  htmlFile << "<td class=\"s1\" align=\"center\">HTR_SLOT</td>" << std::endl;
24188  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FPGA</td>" << std::endl;
24189  htmlFile << "<td class=\"s5\" align=\"center\">Cm</td>" << std::endl;
24190  htmlFile << "<td class=\"s5\" align=\"center\">Am</td>" << std::endl;
24191  htmlFile << "<td class=\"s5\" align=\"center\">Wm</td>" << std::endl;
24192  htmlFile << "<td class=\"s5\" align=\"center\">Rm</td>" << std::endl;
24193  htmlFile << "<td class=\"s5\" align=\"center\">TNm</td>" << std::endl;
24194  htmlFile << "<td class=\"s5\" align=\"center\">TXm</td>" << std::endl;
24195  htmlFile << "<td class=\"s9\" align=\"center\">GS(%)</td>" << std::endl;
24196  htmlFile << "<td class=\"s4\" align=\"center\">Pm</td>" << std::endl;
24197  htmlFile << "<td class=\"s4\" align=\"center\">pWm</td>" << std::endl;
24198  htmlFile << "<td class=\"s8\" align=\"center\">Cc</td>" << std::endl;
24199  htmlFile << "<td class=\"s8\" align=\"center\">Ac</td>" << std::endl;
24200  htmlFile << "<td class=\"s8\" align=\"center\">Wc</td>" << std::endl;
24201  htmlFile << "<td class=\"s8\" align=\"center\">Rc</td>" << std::endl;
24202  htmlFile << "<td class=\"s8\" align=\"center\">TNc</td>" << std::endl;
24203  htmlFile << "<td class=\"s8\" align=\"center\">TXc</td>" << std::endl;
24204  htmlFile << "</tr>" << std::endl;
24205 
24206  for (int i = 1; i <= NWarn; i++) {
24207  if ((ind % 2) == 1) {
24208  raw_class = "<td class=\"s2\" align=\"center\">";
24209  raw_class1 = "<td class=\"s6\" align=\"center\">";
24210  raw_class2 = "<td class=\"s11\" align=\"center\">";
24211  raw_class3 = "<td class=\"s13\" align=\"center\">";
24212 
24213  } else {
24214  raw_class = "<td class=\"s3\" align=\"center\">";
24215  raw_class1 = "<td class=\"s7\" align=\"center\">";
24216  raw_class2 = "<td class=\"s12\" align=\"center\">";
24217  raw_class3 = "<td class=\"s14\" align=\"center\">";
24218  }
24219  const CellDB db;
24220  CellDB ce;
24221  if ((ce.size() >= 1) && (Sub[1][i] == sub)) {
24222  if (Sub[1][i] == 1) {
24223  ce = db.find("subdet", "HB").find("Eta", Eta[1][i]).find("Phi", Phi[1][i]).find("Depth", Depth[1][i]);
24224  if (ce.size() == 0) {
24225  // cout<<"Error: No such HB, Eta="<< Eta[1][i] <<", Phi="<< Phi[1][i] <<", Depth="<< Depth[1][i] <<" in database"<<endl;
24226  continue;
24227  } else if (ce.size() > 1) {
24228  cout << "Warning: More than one line correspond to such HB, Eta=" << Eta[1][i] << ", Phi=" << Phi[1][i]
24229  << ", Depth=" << Depth[1][i] << " in database" << endl;
24230  }
24231  }
24232  if (Sub[1][i] == 2) {
24233  ce = db.find("subdet", "HE").find("Eta", Eta[1][i]).find("Phi", Phi[1][i]).find("Depth", Depth[1][i]);
24234  if (ce.size() == 0) {
24235  // cout<<"Error: No such HE, Eta="<< Eta[1][i] <<", Phi="<< Phi[1][i] <<", Depth="<< Depth[1][i] <<" in database"<<endl;
24236  continue;
24237  } else if (ce.size() > 1) {
24238  cout << "Warning: More than one line correspond to such HE, Eta=" << Eta[1][i] << ", Phi=" << Phi[1][i]
24239  << ", Depth=" << Depth[1][i] << " in database" << endl;
24240  }
24241  }
24242  if (Sub[1][i] == 3) {
24243  ce = db.find("subdet", "HO").find("Eta", Eta[1][i]).find("Phi", Phi[1][i]).find("Depth", Depth[1][i]);
24244  if (ce.size() == 0) {
24245  // cout<<"Error: No such HO, Eta="<< Eta[1][i] <<", Phi="<< Phi[1][i] <<", Depth="<< Depth[1][i] <<" in database"<<endl;
24246  continue;
24247  } else if (ce.size() > 1) {
24248  cout << "Warning: More than one line correspond to such HO, Eta=" << Eta[1][i] << ", Phi=" << Phi[1][i]
24249  << ", Depth=" << Depth[1][i] << " in database" << endl;
24250  }
24251  }
24252  if (Sub[1][i] == 4) {
24253  ce = db.find("subdet", "HF").find("Eta", Eta[1][i]).find("Phi", Phi[1][i]).find("Depth", Depth[1][i]);
24254  if (ce.size() == 0) {
24255  // cout<<"Error: No such HF, Eta="<< Eta[1][i] <<", Phi="<< Phi[1][i] <<", Depth="<< Depth[1][i] <<" in database"<<endl;
24256  continue;
24257  } else if (ce.size() > 1) {
24258  cout << "Warning: More than one line correspond to such HF, Eta=" << Eta[1][i] << ", Phi=" << Phi[1][i]
24259  << ", Depth=" << Depth[1][i] << " in database" << endl;
24260  }
24261  }
24262  htmlFile << "<td class=\"s4\" align=\"center\">" << ind + 1 << "</td>" << std::endl;
24263  htmlFile << raw_class << Eta[1][i] << "</td>" << std::endl;
24264  htmlFile << raw_class << Phi[1][i] << "</td>" << std::endl;
24265  htmlFile << raw_class << Depth[1][i] << "</td>" << std::endl;
24266  htmlFile << raw_class << ce[0].RBX << "</td>" << std::endl;
24267  htmlFile << raw_class << ce[0].RM << "</td>" << std::endl;
24268  htmlFile << raw_class << ce[0].Pixel << "</td>" << std::endl;
24269  htmlFile << raw_class << ce[0].RMfiber << "</td>" << std::endl;
24270  htmlFile << raw_class << ce[0].FiberCh << "</td>" << std::endl;
24271  htmlFile << raw_class << ce[0].QIE << "</td>" << std::endl;
24272  htmlFile << raw_class << ce[0].ADC << "</td>" << std::endl;
24273  htmlFile << raw_class << ce[0].VMECardID << "</td>" << std::endl;
24274  htmlFile << raw_class << ce[0].dccID << "</td>" << std::endl;
24275  htmlFile << raw_class << ce[0].Spigot << "</td>" << std::endl;
24276  htmlFile << raw_class << ce[0].FiberIndex << "</td>" << std::endl;
24277  htmlFile << raw_class << ce[0].HtrSlot << "</td>" << std::endl;
24278  htmlFile << raw_class << ce[0].HtrTB << "</td>" << std::endl;
24279  htmlFile << raw_class1 << Map_Ampl[1][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
24280  << "</td>" << std::endl;
24281  htmlFile << raw_class1 << Map_Ampl[2][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
24282  << "</td>" << std::endl;
24283  htmlFile << raw_class1 << Map_Ampl[3][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
24284  << "</td>" << std::endl;
24285  htmlFile << raw_class1 << Map_Ampl[4][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
24286  << "</td>" << std::endl;
24287  htmlFile << raw_class1 << Map_Ampl[5][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
24288  << "</td>" << std::endl;
24289  htmlFile << raw_class1 << Map_Ampl[6][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
24290  << "</td>" << std::endl;
24291  htmlFile << raw_class3 << Map_Ampl[21][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
24292  << "</td>" << std::endl;
24293  htmlFile << raw_class << Map_Ampl[31][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
24294  << "</td>" << std::endl;
24295  htmlFile << raw_class << Map_Ampl[32][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
24296  << "</td>" << std::endl;
24297  htmlFile << raw_class2 << Map_Ampl[11][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
24298  << "</td>" << std::endl;
24299  htmlFile << raw_class2 << Map_Ampl[12][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
24300  << "</td>" << std::endl;
24301  htmlFile << raw_class2 << Map_Ampl[13][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
24302  << "</td>" << std::endl;
24303  htmlFile << raw_class2 << Map_Ampl[14][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
24304  << "</td>" << std::endl;
24305  htmlFile << raw_class2 << Map_Ampl[15][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
24306  << "</td>" << std::endl;
24307  htmlFile << raw_class2 << Map_Ampl[16][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
24308  << "</td>" << std::endl;
24309  htmlFile << "</tr>" << std::endl;
24310  htmlFile << "</tr>" << std::endl;
24311  ind += 1;
24312  }
24313  }
24314  htmlFile << "</table>" << std::endl;
24315  htmlFile << "<br>" << std::endl;
24316 
24317  htmlFile << "<h3> 2.D.List of channels with Bad Pedestals (rate > 0.1) and its rates (for GS - %)</h3>"
24318  << std::endl;
24319  htmlFile << "<table>" << std::endl;
24320  htmlFile << "<tr>";
24321  htmlFile << "<td class=\"s4\" align=\"center\">#</td>" << std::endl;
24322  htmlFile << "<td class=\"s1\" align=\"center\">ETA</td>" << std::endl;
24323  htmlFile << "<td class=\"s1\" align=\"center\">PHI</td>" << std::endl;
24324  htmlFile << "<td class=\"s1\" align=\"center\">DEPTH</td>" << std::endl;
24325  htmlFile << "<td class=\"s1\" align=\"center\">RBX</td>" << std::endl;
24326  htmlFile << "<td class=\"s1\" align=\"center\">RM</td>" << std::endl;
24327  htmlFile << "<td class=\"s1\" align=\"center\">PIXEL</td>" << std::endl;
24328  htmlFile << "<td class=\"s1\" align=\"center\">RM_FIBER</td>" << std::endl;
24329  htmlFile << "<td class=\"s1\" align=\"center\">FIBER_CH</td>" << std::endl;
24330  htmlFile << "<td class=\"s1\" align=\"center\">QIE</td>" << std::endl;
24331  htmlFile << "<td class=\"s1\" align=\"center\">ADC</td>" << std::endl;
24332  htmlFile << "<td class=\"s1\" align=\"center\">CRATE</td>" << std::endl;
24333  htmlFile << "<td class=\"s1\" align=\"center\">DCC</td>" << std::endl;
24334  htmlFile << "<td class=\"s1\" align=\"center\">SPIGOT</td>" << std::endl;
24335  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FIBER</td>" << std::endl;
24336  htmlFile << "<td class=\"s1\" align=\"center\">HTR_SLOT</td>" << std::endl;
24337  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FPGA</td>" << std::endl;
24338  htmlFile << "<td class=\"s5\" align=\"center\">Cm</td>" << std::endl;
24339  htmlFile << "<td class=\"s5\" align=\"center\">Am</td>" << std::endl;
24340  htmlFile << "<td class=\"s5\" align=\"center\">Wm</td>" << std::endl;
24341  htmlFile << "<td class=\"s5\" align=\"center\">Rm</td>" << std::endl;
24342  htmlFile << "<td class=\"s5\" align=\"center\">TNm</td>" << std::endl;
24343  htmlFile << "<td class=\"s5\" align=\"center\">TXm</td>" << std::endl;
24344  htmlFile << "<td class=\"s9\" align=\"center\">GS(%)</td>" << std::endl;
24345  htmlFile << "<td class=\"s4\" align=\"center\">Pm</td>" << std::endl;
24346  htmlFile << "<td class=\"s4\" align=\"center\">pWm</td>" << std::endl;
24347  htmlFile << "<td class=\"s8\" align=\"center\">Cc</td>" << std::endl;
24348  htmlFile << "<td class=\"s8\" align=\"center\">Ac</td>" << std::endl;
24349  htmlFile << "<td class=\"s8\" align=\"center\">Wc</td>" << std::endl;
24350  htmlFile << "<td class=\"s8\" align=\"center\">Rc</td>" << std::endl;
24351  htmlFile << "<td class=\"s8\" align=\"center\">TNc</td>" << std::endl;
24352  htmlFile << "<td class=\"s8\" align=\"center\">TXc</td>" << std::endl;
24353  htmlFile << "</tr>" << std::endl;
24354 
24355  for (int i = 1; i <= NPed; i++) {
24356  if ((ind % 2) == 1) {
24357  raw_class = "<td class=\"s2\" align=\"center\">";
24358  raw_class1 = "<td class=\"s6\" align=\"center\">";
24359  raw_class2 = "<td class=\"s11\" align=\"center\">";
24360  raw_class3 = "<td class=\"s13\" align=\"center\">";
24361 
24362  } else {
24363  raw_class = "<td class=\"s3\" align=\"center\">";
24364  raw_class1 = "<td class=\"s7\" align=\"center\">";
24365  raw_class2 = "<td class=\"s12\" align=\"center\">";
24366  raw_class3 = "<td class=\"s14\" align=\"center\">";
24367  }
24368  const CellDB db;
24369  CellDB ce;
24370  if ((ce.size() >= 1) && (Sub[3][i] == sub)) {
24371  if (Sub[3][i] == 1) {
24372  ce = db.find("subdet", "HB").find("Eta", Eta[3][i]).find("Phi", Phi[3][i]).find("Depth", Depth[3][i]);
24373  if (ce.size() == 0) {
24374  // cout<<"Error: No such HB, Eta="<< Eta[3][i] <<", Phi="<< Phi[3][i] <<", Depth="<< Depth[3][i] <<" in database"<<endl;
24375  continue;
24376  } else if (ce.size() > 1) {
24377  cout << "Warning: More than one line correspond to such HB, Eta=" << Eta[3][i] << ", Phi=" << Phi[3][i]
24378  << ", Depth=" << Depth[3][i] << " in database" << endl;
24379  }
24380  }
24381  if (Sub[3][i] == 2) {
24382  ce = db.find("subdet", "HE").find("Eta", Eta[3][i]).find("Phi", Phi[3][i]).find("Depth", Depth[3][i]);
24383  if (ce.size() == 0) {
24384  // cout<<"Error: No such HE, Eta="<< Eta[3][i] <<", Phi="<< Phi[3][i] <<", Depth="<< Depth[3][i] <<" in database"<<endl;
24385  continue;
24386  } else if (ce.size() > 1) {
24387  cout << "Warning: More than one line correspond to such HE, Eta=" << Eta[3][i] << ", Phi=" << Phi[3][i]
24388  << ", Depth=" << Depth[3][i] << " in database" << endl;
24389  }
24390  }
24391  if (Sub[3][i] == 3) {
24392  ce = db.find("subdet", "HO").find("Eta", Eta[3][i]).find("Phi", Phi[3][i]).find("Depth", Depth[3][i]);
24393  if (ce.size() == 0) {
24394  // cout<<"Error: No such HO, Eta="<< Eta[3][i] <<", Phi="<< Phi[3][i] <<", Depth="<< Depth[3][i] <<" in database"<<endl;
24395  continue;
24396  } else if (ce.size() > 1) {
24397  cout << "Warning: More than one line correspond to such HO, Eta=" << Eta[3][i] << ", Phi=" << Phi[3][i]
24398  << ", Depth=" << Depth[3][i] << " in database" << endl;
24399  }
24400  }
24401  if (Sub[3][i] == 4) {
24402  ce = db.find("subdet", "HF").find("Eta", Eta[3][i]).find("Phi", Phi[3][i]).find("Depth", Depth[3][i]);
24403  if (ce.size() == 0) {
24404  // cout<<"Error: No such HF, Eta="<< Eta[3][i] <<", Phi="<< Phi[3][i] <<", Depth="<< Depth[3][i] <<" in database"<<endl;
24405  continue;
24406  } else if (ce.size() > 1) {
24407  cout << "Warning: More than one line correspond to such HF, Eta=" << Eta[3][i] << ", Phi=" << Phi[3][i]
24408  << ", Depth=" << Depth[3][i] << " in database" << endl;
24409  }
24410  }
24411  htmlFile << "<td class=\"s4\" align=\"center\">" << ind + 1 << "</td>" << std::endl;
24412  htmlFile << raw_class << Eta[3][i] << "</td>" << std::endl;
24413  htmlFile << raw_class << Phi[3][i] << "</td>" << std::endl;
24414  htmlFile << raw_class << Depth[3][i] << "</td>" << std::endl;
24415  htmlFile << raw_class << ce[0].RBX << "</td>" << std::endl;
24416  htmlFile << raw_class << ce[0].RM << "</td>" << std::endl;
24417  htmlFile << raw_class << ce[0].Pixel << "</td>" << std::endl;
24418  htmlFile << raw_class << ce[0].RMfiber << "</td>" << std::endl;
24419  htmlFile << raw_class << ce[0].FiberCh << "</td>" << std::endl;
24420  htmlFile << raw_class << ce[0].QIE << "</td>" << std::endl;
24421  htmlFile << raw_class << ce[0].ADC << "</td>" << std::endl;
24422  htmlFile << raw_class << ce[0].VMECardID << "</td>" << std::endl;
24423  htmlFile << raw_class << ce[0].dccID << "</td>" << std::endl;
24424  htmlFile << raw_class << ce[0].Spigot << "</td>" << std::endl;
24425  htmlFile << raw_class << ce[0].FiberIndex << "</td>" << std::endl;
24426  htmlFile << raw_class << ce[0].HtrSlot << "</td>" << std::endl;
24427  htmlFile << raw_class << ce[0].HtrTB << "</td>" << std::endl;
24428  htmlFile << raw_class1 << Map_Ampl[1][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
24429  << "</td>" << std::endl;
24430  htmlFile << raw_class1 << Map_Ampl[2][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
24431  << "</td>" << std::endl;
24432  htmlFile << raw_class1 << Map_Ampl[3][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
24433  << "</td>" << std::endl;
24434  htmlFile << raw_class1 << Map_Ampl[4][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
24435  << "</td>" << std::endl;
24436  htmlFile << raw_class1 << Map_Ampl[5][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
24437  << "</td>" << std::endl;
24438  htmlFile << raw_class1 << Map_Ampl[6][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
24439  << "</td>" << std::endl;
24440  htmlFile << raw_class3 << Map_Ampl[21][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
24441  << "</td>" << std::endl;
24442  htmlFile << raw_class << Map_Ampl[31][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
24443  << "</td>" << std::endl;
24444  htmlFile << raw_class << Map_Ampl[32][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
24445  << "</td>" << std::endl;
24446  htmlFile << raw_class2 << Map_Ampl[11][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
24447  << "</td>" << std::endl;
24448  htmlFile << raw_class2 << Map_Ampl[12][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
24449  << "</td>" << std::endl;
24450  htmlFile << raw_class2 << Map_Ampl[13][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
24451  << "</td>" << std::endl;
24452  htmlFile << raw_class2 << Map_Ampl[14][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
24453  << "</td>" << std::endl;
24454  htmlFile << raw_class2 << Map_Ampl[15][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
24455  << "</td>" << std::endl;
24456  htmlFile << raw_class2 << Map_Ampl[16][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
24457  << "</td>" << std::endl;
24458  htmlFile << "</tr>" << std::endl;
24459  htmlFile << "</tr>" << std::endl;
24460  ind += 1;
24461  }
24462  }
24463  htmlFile << "</table>" << std::endl;
24464 
24465  htmlFile << "</body> " << std::endl;
24466  htmlFile << "</html> " << std::endl;
24467  htmlFile.close();
24468  }
24469 
24470  //======================================================================
24471 
24472  std::cout << "********" << std::endl;
24473  std::cout << "************ Start creating description HELP html file:" << std::endl;
24474  //======================================================================
24475  // Creating description html file:
24476  ofstream htmlFile;
24477  htmlFile.open("HELP.html");
24478  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
24479  htmlFile << "<head>" << std::endl;
24480  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
24481  htmlFile << "<title> Remote Monitoring Tool </title>" << std::endl;
24482  htmlFile << "<style type=\"text/css\">" << std::endl;
24483  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
24484  << std::endl;
24485  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
24486  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
24487  "text-align: center;}"
24488  << std::endl;
24489  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
24490  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
24491  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
24492  htmlFile << "</style>" << std::endl;
24493  htmlFile << "<body>" << std::endl;
24494  htmlFile << "<h1> Description of Remote Monitoring Tool criteria for bad channel selection</h1>" << std::endl;
24495  htmlFile << "<br>" << std::endl;
24496  htmlFile << "<h3> - C means CAPID Errors assuming we inspect CAPID non-rotation,error & validation bits, and for "
24497  "this criterion - no need to apply any cuts to select bcs.</h3> "
24498  << std::endl;
24499  htmlFile << "<br>" << std::endl;
24500  htmlFile << "<h3> - A means full amplitude, collected over all time slices </h3> " << std::endl;
24501  htmlFile << "<h3> - R means ratio criterion where we define as a bad, the channels, for which the signal portion in "
24502  "4 middle TSs(plus one, minus two around TS with maximal amplitude) is out of some range of reasonable "
24503  "values </h3> "
24504  << std::endl;
24505  htmlFile << "<br>" << std::endl;
24506  htmlFile << "<h3> - W means width of shape distribution. Width is defined as square root from dispersion. </h3> "
24507  << std::endl;
24508  htmlFile << "<br>" << std::endl;
24509  htmlFile << "<h3> - TN means mean time position of adc signal. </h3> " << std::endl;
24510  htmlFile << "<br>" << std::endl;
24511  htmlFile << "<h3> - TX means TS number of maximum signal </h3> " << std::endl;
24512  htmlFile << "<br>" << std::endl;
24513  htmlFile << "<h3> - m means megatile channels. For example Am means Amplitude criteria for megatile channels </h3> "
24514  << std::endl;
24515  htmlFile << "<br>" << std::endl;
24516  htmlFile
24517  << "<h3> - c means calibration channels. For example Ac means Amplitude criteria for calibration channels </h3> "
24518  << std::endl;
24519  htmlFile << "<br>" << std::endl;
24520  htmlFile << "<h3> - Pm means Pedestals. </h3> " << std::endl;
24521  htmlFile << "<br>" << std::endl;
24522  htmlFile << "<h3> - pWm means pedestal Width. </h3> " << std::endl;
24523  htmlFile << "<br>" << std::endl;
24524  htmlFile << "</body> " << std::endl;
24525  htmlFile << "</html> " << std::endl;
24526  htmlFile.close();
24527 
24528  //======================================================================
24529 
24530  std::cout << "********" << std::endl;
24531  std::cout << "************ Start creating MAP html file: - rather long time needed, waiting please" << std::endl;
24532  //======================================================================
24533  // Creating main html file:
24534  htmlFile.open("MAP.html");
24535  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
24536  htmlFile << "<head>" << std::endl;
24537  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
24538  htmlFile << "<title> Remote Monitoring Tool </title>" << std::endl;
24539  htmlFile << "<style type=\"text/css\">" << std::endl;
24540  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
24541  << std::endl;
24542  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
24543  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
24544  "text-align: center;}"
24545  << std::endl;
24546  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
24547  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
24548  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
24549  htmlFile << " td.s5 { font-family: arial, arial ce, helvetica; background-color: #FF00FF; }" << std::endl;
24550  htmlFile << " td.s6 { font-family: arial, arial ce, helvetica; background-color: #9ACD32; }" << std::endl;
24551  htmlFile << " td.s7 { font-family: arial, arial ce, helvetica; background-color: #32CD32; }" << std::endl;
24552  htmlFile << "</style>" << std::endl;
24553  htmlFile << "<body>" << std::endl;
24554 
24555  htmlFile << "<h1> Remote Monitoring Tool, LED RUN = " << runnumber << ". </h1>" << std::endl;
24556  htmlFile << "<br>" << std::endl;
24557 
24558  htmlFile << "<h2> 1. Analysis results for subdetectors </h2>" << std::endl;
24559  htmlFile << "<table width=\"400\">" << std::endl;
24560  htmlFile << "<tr>" << std::endl;
24561 
24562  htmlFile << " <td><a href=\"HB.html\">HB</a></td>" << std::endl;
24563  htmlFile << " <td><a href=\"HE.html\">HE</a></td>" << std::endl;
24564  htmlFile << " <td><a href=\"HO.html\">HO</a></td>" << std::endl;
24565  htmlFile << " <td><a href=\"HF.html\">HF</a></td>" << std::endl;
24566 
24567  /*
24568  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HB.html\">HB</a></td>"<< std::endl;
24569  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HE.html\">HE</a></td>"<< std::endl;
24570  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HO.html\">HO</a></td>"<< std::endl;
24571  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_"<<runnumber<<"/HF.html\">HF</a></td>"<< std::endl;
24572 */
24573 
24574  htmlFile << "</tr>" << std::endl;
24575  htmlFile << "</table>" << std::endl;
24576  htmlFile << "<br>" << std::endl;
24577 
24578  htmlFile << "<h2> 2. Amplitude summed over all sub-detector channels vs first 1000 events of this Run </h2>"
24579  << std::endl;
24580  htmlFile << "<h3> 2.A. Total subdetector Amplitude vs iEvent </h3>" << std::endl;
24581  htmlFile << " <img src=\"EVENTDEPENDENCE.png\" />" << std::endl;
24582  htmlFile << "<br>" << std::endl;
24583  htmlFile << "<br>" << std::endl;
24584  htmlFile << "<br>" << std::endl;
24585 
24586  htmlFile << "<h2> 3. HCAL status over all criteria and subdetectors </h2>" << std::endl;
24587  htmlFile << "<h3> 3.A. Channels in detector space </h3>" << std::endl;
24588  htmlFile << "<h4> Legend for channel status: green - good, red - bad, yellow - at least 2% gain drift, white - not "
24589  "applicable or out of range </h4>"
24590  << std::endl;
24591  htmlFile << " <img src=\"MAP.png\" />" << std::endl;
24592  htmlFile << "<br>" << std::endl;
24593  htmlFile << "<br>" << std::endl;
24594 
24595  htmlFile << "<h3> 3.B. List of Bad channels </h3>" << std::endl;
24596 
24597  // htmlFile << " <td><a href=\"HELP.html\"> Description of criteria for bad channel selection</a></td>"<< std::endl;
24598  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_" << runnumber
24599  << "/HELP.html\"> Description of criteria for bad channel selection</a></td>" << std::endl;
24600  htmlFile << "<table>" << std::endl;
24601  htmlFile << "<tr>";
24602  htmlFile << "<td class=\"s4\" align=\"center\">#</td>" << std::endl;
24603  htmlFile << "<td class=\"s1\" align=\"center\">ETA</td>" << std::endl;
24604  htmlFile << "<td class=\"s1\" align=\"center\">PHI</td>" << std::endl;
24605  htmlFile << "<td class=\"s1\" align=\"center\">DEPTH</td>" << std::endl;
24606  htmlFile << "<td class=\"s1\" align=\"center\">RBX</td>" << std::endl;
24607  htmlFile << "<td class=\"s1\" align=\"center\">RM</td>" << std::endl;
24608  htmlFile << "<td class=\"s1\" align=\"center\">PIXEL</td>" << std::endl;
24609  htmlFile << "<td class=\"s1\" align=\"center\">RM_FIBER</td>" << std::endl;
24610  htmlFile << "<td class=\"s1\" align=\"center\">FIBER_CH</td>" << std::endl;
24611  htmlFile << "<td class=\"s1\" align=\"center\">QIE</td>" << std::endl;
24612  htmlFile << "<td class=\"s1\" align=\"center\">ADC</td>" << std::endl;
24613  htmlFile << "<td class=\"s1\" align=\"center\">CRATE</td>" << std::endl;
24614  htmlFile << "<td class=\"s1\" align=\"center\">DCC</td>" << std::endl;
24615  htmlFile << "<td class=\"s1\" align=\"center\">SPIGOT</td>" << std::endl;
24616  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FIBER</td>" << std::endl;
24617  htmlFile << "<td class=\"s1\" align=\"center\">HTR_SLOT</td>" << std::endl;
24618  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FPGA</td>" << std::endl;
24619  htmlFile << "<td class=\"s5\" align=\"center\">RMT-criteria</td>" << std::endl;
24620  htmlFile << "</tr>" << std::endl;
24621 
24622  ind = 0;
24623 
24624  for (int i = 1; i <= NBad; i++) {
24625  if ((ind % 2) == 1) {
24626  raw_class = "<td class=\"s2\" align=\"center\">";
24627  raw_class1 = "<td class=\"s6\" align=\"center\">";
24628  } else {
24629  raw_class = "<td class=\"s3\" align=\"center\">";
24630  raw_class1 = "<td class=\"s7\" align=\"center\">";
24631  }
24632  const CellDB db;
24633  const CellDB ce = db.find("Eta", Eta[2][i]).find("Phi", Phi[2][i]).find("Depth", Depth[2][i]);
24634  if (ce.size() == 0) {
24635  // cout<<"Error: No such Eta="<< Eta[2][i] <<", Phi="<< Phi[2][i] <<", Depth="<< Depth[2][i] <<" in database"<<endl;
24636  continue;
24637  }
24638  // 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;}
24639 
24640  if (ce.size() >= 1) {
24641  htmlFile << "<tr>" << std::endl;
24642  htmlFile << "<td class=\"s1\" align=\"center\">" << ind + 1 << "</td>" << std::endl;
24643  htmlFile << raw_class << Eta[2][i] << "</td>" << std::endl;
24644  htmlFile << raw_class << Phi[2][i] << "</td>" << std::endl;
24645  htmlFile << raw_class << Depth[2][i] << "</td>" << std::endl;
24646  htmlFile << raw_class << ce[0].RBX << "</td>" << std::endl;
24647  htmlFile << raw_class << ce[0].RM << "</td>" << std::endl;
24648  htmlFile << raw_class << ce[0].Pixel << "</td>" << std::endl;
24649  htmlFile << raw_class << ce[0].RMfiber << "</td>" << std::endl;
24650  htmlFile << raw_class << ce[0].FiberCh << "</td>" << std::endl;
24651  htmlFile << raw_class << ce[0].QIE << "</td>" << std::endl;
24652  htmlFile << raw_class << ce[0].ADC << "</td>" << std::endl;
24653  htmlFile << raw_class << ce[0].VMECardID << "</td>" << std::endl;
24654  htmlFile << raw_class << ce[0].dccID << "</td>" << std::endl;
24655  htmlFile << raw_class << ce[0].Spigot << "</td>" << std::endl;
24656  htmlFile << raw_class << ce[0].FiberIndex << "</td>" << std::endl;
24657  htmlFile << raw_class << ce[0].HtrSlot << "</td>" << std::endl;
24658  htmlFile << raw_class << ce[0].HtrTB << "</td>" << std::endl;
24659  htmlFile << raw_class1 << Comment[2][i] << "</td>" << std::endl;
24660  htmlFile << "</tr>" << std::endl;
24661 
24662  ind += 1;
24663  }
24664  }
24665  htmlFile << "</table>" << std::endl;
24666  htmlFile << "<br>" << std::endl;
24667 
24668  htmlFile << "<h3> 2.C.List of Gain unstable channels </h3>" << std::endl;
24669  // htmlFile << " <td><a href=\"HELP.html\"> Description of criteria for bad channel selection</a></td>"<< std::endl;
24670  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_" << runnumber
24671  << "/HELP.html\"> Description of criteria for bad channel selection</a></td>" << std::endl;
24672 
24673  htmlFile << "<table>" << std::endl;
24674  htmlFile << "<tr>";
24675  htmlFile << "<td class=\"s4\" align=\"center\">#</td>" << std::endl;
24676  htmlFile << "<td class=\"s1\" align=\"center\">ETA</td>" << std::endl;
24677  htmlFile << "<td class=\"s1\" align=\"center\">PHI</td>" << std::endl;
24678  htmlFile << "<td class=\"s1\" align=\"center\">DEPTH</td>" << std::endl;
24679  htmlFile << "<td class=\"s1\" align=\"center\">RBX</td>" << std::endl;
24680  htmlFile << "<td class=\"s1\" align=\"center\">RM</td>" << std::endl;
24681  htmlFile << "<td class=\"s1\" align=\"center\">PIXEL</td>" << std::endl;
24682  htmlFile << "<td class=\"s1\" align=\"center\">RM_FIBER</td>" << std::endl;
24683  htmlFile << "<td class=\"s1\" align=\"center\">FIBER_CH</td>" << std::endl;
24684  htmlFile << "<td class=\"s1\" align=\"center\">QIE</td>" << std::endl;
24685  htmlFile << "<td class=\"s1\" align=\"center\">ADC</td>" << std::endl;
24686  htmlFile << "<td class=\"s1\" align=\"center\">CRATE</td>" << std::endl;
24687  htmlFile << "<td class=\"s1\" align=\"center\">DCC</td>" << std::endl;
24688  htmlFile << "<td class=\"s1\" align=\"center\">SPIGOT</td>" << std::endl;
24689  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FIBER</td>" << std::endl;
24690  htmlFile << "<td class=\"s1\" align=\"center\">HTR_SLOT</td>" << std::endl;
24691  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FPGA</td>" << std::endl;
24692  htmlFile << "<td class=\"s5\" align=\"center\">Failed criteria</td>" << std::endl;
24693  htmlFile << "</tr>" << std::endl;
24694 
24695  for (int i = 1; i <= NWarn; i++) {
24696  if ((ind % 2) == 1) {
24697  raw_class = "<td class=\"s2\" align=\"center\">";
24698  raw_class1 = "<td class=\"s6\" align=\"center\">";
24699  } else {
24700  raw_class = "<td class=\"s3\" align=\"center\">";
24701  raw_class1 = "<td class=\"s7\" align=\"center\">";
24702  }
24703  const CellDB db;
24704  const CellDB ce = db.find("Eta", Eta[1][i]).find("Phi", Phi[1][i]).find("Depth", Depth[1][i]);
24705  if (ce.size() == 0) {
24706  // cout<<"Error: No such Eta="<< Eta[1][i] <<", Phi="<< Phi[1][i] <<", Depth="<< Depth[1][i] <<" in database"<<endl;
24707  continue;
24708  }
24709  // 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;}
24710 
24711  if (ce.size() >= 1) {
24712  htmlFile << "<tr>" << std::endl;
24713  htmlFile << "<td class=\"s1\" align=\"center\">" << ind + 1 << "</td>" << std::endl;
24714  htmlFile << raw_class << Eta[1][i] << "</td>" << std::endl;
24715  htmlFile << raw_class << Phi[1][i] << "</td>" << std::endl;
24716  htmlFile << raw_class << Depth[1][i] << "</td>" << std::endl;
24717  htmlFile << raw_class << ce[0].RBX << "</td>" << std::endl;
24718  htmlFile << raw_class << ce[0].RM << "</td>" << std::endl;
24719  htmlFile << raw_class << ce[0].Pixel << "</td>" << std::endl;
24720  htmlFile << raw_class << ce[0].RMfiber << "</td>" << std::endl;
24721  htmlFile << raw_class << ce[0].FiberCh << "</td>" << std::endl;
24722  htmlFile << raw_class << ce[0].QIE << "</td>" << std::endl;
24723  htmlFile << raw_class << ce[0].ADC << "</td>" << std::endl;
24724  htmlFile << raw_class << ce[0].VMECardID << "</td>" << std::endl;
24725  htmlFile << raw_class << ce[0].dccID << "</td>" << std::endl;
24726  htmlFile << raw_class << ce[0].Spigot << "</td>" << std::endl;
24727  htmlFile << raw_class << ce[0].FiberIndex << "</td>" << std::endl;
24728  htmlFile << raw_class << ce[0].HtrSlot << "</td>" << std::endl;
24729  htmlFile << raw_class << ce[0].HtrTB << "</td>" << std::endl;
24730  htmlFile << raw_class1 << Comment[1][i] << "</td>" << std::endl;
24731  htmlFile << "</tr>" << std::endl;
24732 
24733  ind += 1;
24734  }
24735  }
24736 
24737  htmlFile << "</table>" << std::endl;
24738  htmlFile << "<br>" << std::endl;
24739 
24740  htmlFile << "<h3> 2.D.List of channels with bad Pedestals </h3>" << std::endl;
24741  // htmlFile << " <td><a href=\"HELP.html\"> Description of criteria for bad channel selection</a></td>"<< std::endl;
24742  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT/LED_" << runnumber
24743  << "/HELP.html\"> Description of criteria for bad channel selection</a></td>" << std::endl;
24744 
24745  htmlFile << "<table>" << std::endl;
24746  htmlFile << "<tr>";
24747  htmlFile << "<td class=\"s4\" align=\"center\">#</td>" << std::endl;
24748  htmlFile << "<td class=\"s1\" align=\"center\">ETA</td>" << std::endl;
24749  htmlFile << "<td class=\"s1\" align=\"center\">PHI</td>" << std::endl;
24750  htmlFile << "<td class=\"s1\" align=\"center\">DEPTH</td>" << std::endl;
24751  htmlFile << "<td class=\"s1\" align=\"center\">RBX</td>" << std::endl;
24752  htmlFile << "<td class=\"s1\" align=\"center\">RM</td>" << std::endl;
24753  htmlFile << "<td class=\"s1\" align=\"center\">PIXEL</td>" << std::endl;
24754  htmlFile << "<td class=\"s1\" align=\"center\">RM_FIBER</td>" << std::endl;
24755  htmlFile << "<td class=\"s1\" align=\"center\">FIBER_CH</td>" << std::endl;
24756  htmlFile << "<td class=\"s1\" align=\"center\">QIE</td>" << std::endl;
24757  htmlFile << "<td class=\"s1\" align=\"center\">ADC</td>" << std::endl;
24758  htmlFile << "<td class=\"s1\" align=\"center\">CRATE</td>" << std::endl;
24759  htmlFile << "<td class=\"s1\" align=\"center\">DCC</td>" << std::endl;
24760  htmlFile << "<td class=\"s1\" align=\"center\">SPIGOT</td>" << std::endl;
24761  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FIBER</td>" << std::endl;
24762  htmlFile << "<td class=\"s1\" align=\"center\">HTR_SLOT</td>" << std::endl;
24763  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FPGA</td>" << std::endl;
24764  htmlFile << "<td class=\"s5\" align=\"center\">Failed criteria</td>" << std::endl;
24765  htmlFile << "</tr>" << std::endl;
24766 
24767  for (int i = 1; i <= NPed; i++) {
24768  if ((ind % 2) == 1) {
24769  raw_class = "<td class=\"s2\" align=\"center\">";
24770  raw_class1 = "<td class=\"s6\" align=\"center\">";
24771  } else {
24772  raw_class = "<td class=\"s3\" align=\"center\">";
24773  raw_class1 = "<td class=\"s7\" align=\"center\">";
24774  }
24775  const CellDB db;
24776  const CellDB ce = db.find("Eta", Eta[3][i]).find("Phi", Phi[3][i]).find("Depth", Depth[3][i]);
24777  if (ce.size() == 0) {
24778  // cout<<"Error: No such Eta="<< Eta[3][i] << ", Phi="<< Phi[3][i] <<", Depth="<< Depth[3][i] <<" in database"<<endl;
24779  continue;
24780  }
24781  // 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;}
24782 
24783  if (ce.size() >= 1) {
24784  htmlFile << "<tr>" << std::endl;
24785  htmlFile << "<td class=\"s1\" align=\"center\">" << ind + 1 << "</td>" << std::endl;
24786  htmlFile << raw_class << Eta[3][i] << "</td>" << std::endl;
24787  htmlFile << raw_class << Phi[3][i] << "</td>" << std::endl;
24788  htmlFile << raw_class << Depth[3][i] << "</td>" << std::endl;
24789  htmlFile << raw_class << ce[0].RBX << "</td>" << std::endl;
24790  htmlFile << raw_class << ce[0].RM << "</td>" << std::endl;
24791  htmlFile << raw_class << ce[0].Pixel << "</td>" << std::endl;
24792  htmlFile << raw_class << ce[0].RMfiber << "</td>" << std::endl;
24793  htmlFile << raw_class << ce[0].FiberCh << "</td>" << std::endl;
24794  htmlFile << raw_class << ce[0].QIE << "</td>" << std::endl;
24795  htmlFile << raw_class << ce[0].ADC << "</td>" << std::endl;
24796  htmlFile << raw_class << ce[0].VMECardID << "</td>" << std::endl;
24797  htmlFile << raw_class << ce[0].dccID << "</td>" << std::endl;
24798  htmlFile << raw_class << ce[0].Spigot << "</td>" << std::endl;
24799  htmlFile << raw_class << ce[0].FiberIndex << "</td>" << std::endl;
24800  htmlFile << raw_class << ce[0].HtrSlot << "</td>" << std::endl;
24801  htmlFile << raw_class << ce[0].HtrTB << "</td>" << std::endl;
24802  htmlFile << raw_class1 << Comment[3][i] << "</td>" << std::endl;
24803  htmlFile << "</tr>" << std::endl;
24804 
24805  ind += 1;
24806  }
24807  }
24808 
24809  htmlFile << "</table>" << std::endl;
24810 
24811  htmlFile << "</body> " << std::endl;
24812  htmlFile << "</html> " << std::endl;
24813  htmlFile.close();
24814  //======================================================================
24815 
24816  //======================================================================
24817  // Close and delete all possible things:
24818  hfile->Close();
24819  // hfile->Delete();
24820  // Exit Root
24821  gSystem->Exit(0);
24822  //======================================================================
24823 }
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