Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-04-06 12:06:19 

0001 // How to run:
0002 //root -b -q -l 'RemoteMonitoringMAP.C+("/afs/cern.ch/cms/CAF/CMSALCA/ALCA_HCALCALIB/HCALMONITORING/RDMweb/histos/LED_214513.root","/afs/cern.ch/cms/CAF/CMSALCA/ALCA_HCALCALIB/HCALMONITORING/RDMweb/histos/LED_214512.root")'
0003 //root -b -q -l 'RemoteMonitoringMAP.C+(" /afs/cern.ch/work/d/dtlisov/private/Monitoring/histos/LED_211659.root","/afs/cern.ch/cms/CAF/CMSALCA/ALCA_HCALCALIB/HCALMONITORING/RDMweb/histos/LED_214512.root")'
0004 // ./RemoteMonitoringMAP.cc.exe root_file1  root_file_ref PEDESTAL
0005 //./RemoteMonitoringMAP.cc.exe root_file1  root_file_ref LASER
0006 
0007 //MapRateAmpl2HB
0008 
0009 #include "LogEleMapdb.h"
0010 
0011 #include <iostream>
0012 #include <fstream>
0013 
0014 #include "TH1.h"
0015 #include "TH2.h"
0016 #include "TCanvas.h"
0017 #include "TROOT.h"
0018 #include <TMath.h>
0019 #include "TStyle.h"
0020 #include "TSystem.h"
0021 #include "TLegend.h"
0022 #include "TText.h"
0023 #include "TAxis.h"
0024 #include "TFile.h"
0025 #include "TLine.h"
0026 #include "TGraph.h"
0027 
0028 // https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/RMT
0029 // https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/HcalRemoteMonitoring/RMT
0030 
0031 using namespace std;
0032 // h_ADC_HBdepth1
0033 // ok change   Hist_ADC_HB_DS
0034 int main(int argc, char *argv[]) {
0035   std::string dirnm = "Analyzer";
0036   gROOT->Reset();
0037   gROOT->SetStyle("Plain");
0038   gStyle->SetOptStat(0);
0039   gStyle->SetOptTitle(1);
0040   // ok change
0041   if (argc < 3)
0042     return 1;
0043   char fname[300];
0044   char refname[300];
0045   char runtypeC[300];
0046   sprintf(fname, "%s", argv[1]);
0047   sprintf(refname, "%s", argv[2]);
0048   sprintf(runtypeC, "%s", argv[3]);
0049   std::cout << fname << " " << refname << " " << runtypeC << std::endl;
0050   // ok change
0051 
0052   //======================================================================
0053   // Connect the input files, parameters and get the 2-d histogram in memory
0054   //    TFile *hfile= new TFile("GlobalHist.root", "READ");
0055   string promt = (string)fname;
0056   string runtype = (string)runtypeC;
0057   string runnumber = "";
0058   for (unsigned int i = promt.size() - 11; i < promt.size() - 5; i++)
0059     runnumber += fname[i];
0060   string refrunnumber = "";
0061   promt = (string)refname;
0062   for (unsigned int i = promt.size() - 11; i < promt.size() - 5; i++)
0063     refrunnumber += refname[i];
0064 
0065   TFile *hfile = new TFile(fname, "READ");
0066   hfile->ls();
0067   TDirectory *dir = (TDirectory *)hfile->FindObjectAny(dirnm.c_str());
0068   TFile *hreffile = new TFile(refname, "READ");
0069   hreffile->ls();
0070   TDirectory *refdir = (TDirectory *)hreffile->FindObjectAny(dirnm.c_str());
0071 
0072   // with TfileService implementation, change everywhere below:     hreffile->Get     to     refdir->FindObjectAny
0073   // with TfileService implementation, change everywhere below:     hfile->Get     to     dir->FindObjectAny
0074 
0075   double MIN_M[7][5];
0076   double MAX_M[7][5];
0077   double MIN_C[7][5];
0078   double MAX_C[7][5];
0079   double porog[5];
0080   double Pedest[2][5];
0081 
0082   if (runtype == "LED") {
0083     //CUTS:    [test][subdetector]                                       ADC amplitude  Am      Width  for Wm             Ratio cut for Rm             TS mean for TNm           TS max  for TXm
0084     double MIN_M_LED[7][5] = {{0., 0., 0., 0., 0.},
0085                               {0., 0., 0., 0., 0.},
0086                               {0, 100., 70., 40., 40.},
0087                               {0, 0.7, 0.7, 0.1, 0.1},
0088                               {0, 0.7, 0.6, 0.40, 0.45},
0089                               {0, 2.5, 1.0, 1.0, 1.0},
0090                               {0, 1.5, 1.5, 0.5, 0.5}};
0091     double MAX_M_LED[7][5] = {{0., 0., 0., 0., 0.},
0092                               {0., 0., 0., 0., 0.},
0093                               {0, 3000, 500000, 3000, 150000},
0094                               {0, 2.5, 2.5, 2.8, 2.6},
0095                               {0, 0.94, 0.95, 1.04, 1.02},
0096                               {0, 5.5, 5.2, 4.8, 4.2},
0097                               {0, 6.5, 6.5, 8.5, 8.5}};
0098     double MIN_C_LED[7][5] = {{0., 0., 0., 0., 0.},
0099                               {0., 0., 0., 0., 0.},
0100                               {0, 1000., 1000., 1000., 100.},
0101                               {0, 1.3, 1.3, 0.7, 0.3},
0102                               {0, 0.76, 0.76, 0.85, 0.5},
0103                               {0, 2.4, 2.4, 1.5, 3.5},
0104                               {0, 1.5, 1.5, 1.5, 3.5}};
0105     double MAX_C_LED[7][5] = {{0., 0., 0., 0., 0.},
0106                               {0., 0., 0., 0., 0.},
0107                               {0, 1E20, 1E20, 1E20, 1E20},
0108                               {0, 1.9, 1.9, 1.65, 1.5},
0109                               {0, 0.94, 0.94, 0.99, 0.8},
0110                               {0, 3.7, 3.7, 2.7, 4.5},
0111                               {0, 2.5, 2.5, 2.5, 4.5}};
0112     double porog_LED[5] = {0., 2., 2., 2., 2.};  // Cut for GS test in pro cents
0113     double Pedest_LED[2][5] = {{0., 0.1, 0.6, 0.1, 0.8},
0114                                {0., 0.1, 0.1, 0.1, 0.4}};  //Cuts for Pedestal  and pedestal  Width
0115     for (int i = 0; i <= 6; i++)
0116       for (int j = 0; j <= 4; j++) {
0117         MIN_M[i][j] = MIN_M_LED[i][j];
0118         MAX_M[i][j] = MAX_M_LED[i][j];
0119         MIN_C[i][j] = MIN_C_LED[i][j];
0120         MAX_C[i][j] = MAX_C_LED[i][j];
0121       }
0122     for (int i = 0; i <= 4; i++) {
0123       porog[i] = porog_LED[i];
0124       Pedest[0][i] = Pedest_LED[0][i];
0125       Pedest[1][i] = Pedest_LED[1][i];
0126     }
0127   }
0128 
0129   if (runtype == "LASER") {
0130     //CUTS:    [test][subdetector]                                  ADC amplitude  Am      Width  for Wm             Ratio cut for Rm             TS mean for TNm           TS max  for TXm
0131     double MIN_M_LASER[7][5] = {{0., 0., 0., 0., 0.},
0132                                 {0., 0., 0., 0., 0.},
0133                                 {0, 40., 40., 100., 40.},
0134                                 {0, 0.3, 0.9, 0.2, 0.2},
0135                                 {0, 0.5, 0.55, 0.55, 0.60},
0136                                 {0, 5.0, 2.5, 1.1, 5.5},
0137                                 {0, 1.5, 1.5, 1.5, 1.5}};
0138     double MAX_M_LASER[7][5] = {{0., 0., 0., 0., 0.},
0139                                 {0., 0., 0., 0., 0.},
0140                                 {0, 3500, 350000, 3500, 150000},
0141                                 {0, 2.5, 3.6, 2.6, 2.1},
0142                                 {0, 1.00, 1.00, 1.04, 1.02},
0143                                 {0, 7.5, 6.5, 4.4, 8.5},
0144                                 {0, 8.5, 8.5, 6.5, 8.5}};
0145     double MIN_C_LASER[7][5] = {{0., 0., 0., 0., 0.},
0146                                 {0., 0., 0., 0., 0.},
0147                                 {0, 1000., 1000., 1000., 100.},
0148                                 {0, 1.3, 1.3, 0.7, 0.3},
0149                                 {0, 0.76, 0.76, 0.85, 0.5},
0150                                 {0, 2.4, 2.4, 1.5, 3.5},
0151                                 {0, 1.5, 1.5, 1.5, 3.5}};
0152     double MAX_C_LASER[7][5] = {{0., 0., 0., 0., 0.},
0153                                 {0., 0., 0., 0., 0.},
0154                                 {0, 1E20, 1E20, 1E20, 1E20},
0155                                 {0, 1.9, 1.9, 1.65, 1.5},
0156                                 {0, 0.94, 0.94, 1.0, 0.8},
0157                                 {0, 3.7, 3.7, 2.7, 4.5},
0158                                 {0, 2.5, 2.5, 2.5, 4.5}};
0159     double porog_LASER[5] = {0., 2., 2., 2., 2.};  // Cut for GS test in pro cents
0160     //     double porog_LASER[5] = {0., 200., 200., 100., 100.}; // Cut for GS test in pro cents
0161     double Pedest_LASER[2][5] = {{0., 0.1, 0.6, 0.1, 0.8},
0162                                  {0., 0.1, 0.1, 0.1, 0.4}};  //Cuts for Pedestal  and pedestal  Width
0163     for (int i = 0; i <= 6; i++)
0164       for (int j = 0; j <= 4; j++) {
0165         MIN_M[i][j] = MIN_M_LASER[i][j];
0166         MAX_M[i][j] = MAX_M_LASER[i][j];
0167         MIN_C[i][j] = MIN_C_LASER[i][j];
0168         MAX_C[i][j] = MAX_C_LASER[i][j];
0169       }
0170     for (int i = 0; i <= 4; i++) {
0171       porog[i] = porog_LASER[i];
0172       Pedest[0][i] = Pedest_LASER[0][i];
0173       Pedest[1][i] = Pedest_LASER[1][i];
0174     }
0175   }
0176   if (runtype == "PEDESTAL") {
0177     //CUTS:    [test][subdetector]                                  ADC amplitude  Am      Width  for Wm             Ratio cut for Rm             TS mean for TNm           TS max  for TXm
0178     double MIN_M_PEDESTAL[7][5] = {{0., 0., 0., 0., 0.},
0179                                    {0., 0., 0., 0., 0.},
0180                                    {0, 10., 10., 200., 5.},
0181                                    {0, 2.7, 2.7, 2.7, 0.2},
0182                                    {0, 0.31, 0.31, 0.05, 0.15},
0183                                    {0, 4.5, 4.5, 4.5, 2.0},
0184                                    {0, 0.5, 0.5, 0.5, 0.5}};
0185     double MAX_M_PEDESTAL[7][5] = {{0., 0., 0., 0., 0.},
0186                                    {0., 0., 0., 0., 0.},
0187                                    {0, 2500., 250000., 2500., 150000.},
0188                                    {0, 3.0, 3.0, 5.0, 3.0},
0189                                    {0, 0.95, 0.95, 1.00, 0.98},
0190                                    {0, 4.6, 4.6, 4.6, 7.0},
0191                                    {0, 9.5, 9.5, 8.5, 8.5}};
0192     double MIN_C_PEDESTAL[7][5] = {{0., 0., 0., 0., 0.},
0193                                    {0., 0., 0., 0., 0.},
0194                                    {0, 1000., 1000., 1000., 100.},
0195                                    {0, 1.3, 1.3, 0.7, 0.3},
0196                                    {0, 0.76, 0.76, 0.85, 0.5},
0197                                    {0, 2.4, 2.4, 1.5, 3.5},
0198                                    {0, 1.5, 1.5, 1.5, 3.5}};
0199     double MAX_C_PEDESTAL[7][5] = {{0., 0., 0., 0., 0.},
0200                                    {0., 0., 0., 0., 0.},
0201                                    {0, 1E20, 1E20, 1E20, 1E20},
0202                                    {0, 1.9, 1.9, 1.65, 1.5},
0203                                    {0, 0.94, 0.94, 1.0, 0.8},
0204                                    {0, 3.7, 3.7, 2.7, 4.5},
0205                                    {0, 2.5, 2.5, 2.5, 4.5}};
0206     double porog_PEDESTAL[5] = {0., 2., 2., 2., 2.};  // Cut for GS test in pro cents
0207     //     double porog_PEDESTAL[5] = {0., 200., 200., 100., 100.}; // Cut for GS test in pro cents
0208     double Pedest_PEDESTAL[2][5] = {{0., 0.1, 0.6, 0.1, 0.8},
0209                                     {0., 0.1, 0.1, 0.1, 0.4}};  //Cuts for Pedestal  and pedestal  Width
0210     for (int i = 0; i <= 6; i++)
0211       for (int j = 0; j <= 4; j++) {
0212         MIN_M[i][j] = MIN_M_PEDESTAL[i][j];
0213         MAX_M[i][j] = MAX_M_PEDESTAL[i][j];
0214         MIN_C[i][j] = MIN_C_PEDESTAL[i][j];
0215         MAX_C[i][j] = MAX_C_PEDESTAL[i][j];
0216       }
0217     for (int i = 0; i <= 4; i++) {
0218       porog[i] = porog_PEDESTAL[i];
0219       Pedest[0][i] = Pedest_PEDESTAL[0][i];
0220       Pedest[1][i] = Pedest_PEDESTAL[1][i];
0221     }
0222   }
0223 
0224   //======================================================================
0225 
0226   cout << endl;
0227   cout << MIN_M[2][1] << endl;
0228 
0229   //======================================================================
0230   // Prepare histograms and plot them to .png files
0231 
0232   //TCanvas *cHB = new TCanvas("cHB","cHB",1000,500);
0233   TCanvas *cHB = new TCanvas("cHB", "cHB", 1000, 1000);
0234   //TCanvas *cHE = new TCanvas("cHE","cHE",1500,500);
0235   TCanvas *cHE = new TCanvas("cHE", "cHE", 1500, 1500);
0236   //TCanvas *cONE = new TCanvas("cONE","cONE",500,500);
0237   TCanvas *cONE = new TCanvas("cONE", "cONE", 1500, 500);
0238   TCanvas *cPED = new TCanvas("cPED", "cPED", 1000, 500);
0239   //TCanvas *cHF = new TCanvas("cHF","cHF",1000,1000);
0240   TCanvas *cHF = new TCanvas("cHF", "cHF", 1000, 1000);
0241 
0242   // Phi-symmetry for Calibration Group:
0243 
0244   TCanvas *c1x0 = new TCanvas("c1x0", "c1x0", 300, 10, 800, 700);
0245 
0246   TCanvas *c1x1 = new TCanvas("c1x1", "c1x1", 100, 10, 600, 700);
0247 
0248   TCanvas *c2x1 = new TCanvas("c2x1", "c2x1", 200, 300, 1600, 800);
0249 
0250   TCanvas *c3x5 = new TCanvas("c3x5", "c3x5", 1000, 1500);
0251   //
0252 
0253   char *str = (char *)alloca(10000);
0254 
0255   // before upgrade 2017:
0256   // depth: HB depth1,2; HE depth1,2,3; HO depth4; HF depth1,2
0257   // 5 depthes:  0(empty),   1,2,3,4
0258 
0259   // upgrade 2017:
0260   // depth: HB depth1,2; HE depth1,2,3,4,5,6,7; HO depth4; HF depth1,2,3,4
0261   // 8 depthes:  0(empty),   1,2,3,4,5,6,7
0262 
0263   // upgrade 2021:
0264   // depth: HB depth1,2,3,4; HE depth1,2,3,4,5,6,7; HO depth4; HF depth1,2,3,4
0265   // 10 depthes:  0(empty),   1,2,3,4,5,6,7,8,9
0266 
0267   //  Int_t ALLDEPTH = 5;
0268   //  Int_t ALLDEPTH = 8;
0269   Int_t ALLDEPTH = 10;
0270 
0271   int k_min[5] = {0, 1, 1, 4, 1};  // minimum depth for each subdet
0272   //     int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
0273   //       int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
0274   int k_max[5] = {0, 4, 7, 4, 4};  // maximum depth for each subdet
0275 
0276   TH2F *Map_Ampl[33][5][ALLDEPTH];       // 2D histogramm for test,subdet,depth
0277   TH2F *Map_SUB[5][ALLDEPTH];            // 2d histogramm for subdet, depth
0278   TH1F *HistAmplDepth[22][5][ALLDEPTH];  // 1d histogramm for test,subdet, depth
0279   TH1F *HistAmpl[22][5];                 // 1d histogramm for test,subdet
0280   TH2F *Map_SUBTS[5][ALLDEPTH];          // 2d histogramm for subdet, depth in different TSs
0281 
0282   TH1F *HistPed[3][5][4];           // 1d  histogramm for test,subdet, CapID
0283   TH2F *Map_Ped[3][5];              // 2d  histogramm for test,subdet -> test 33
0284   TH1F *hist_GoodTSshape[5];        // 1d  histogramm for TS shape subdet -> test 41
0285   TH1F *hist_GoodTSshape0[5];       // 1d  histogramm for TS shape subdet -> test 41
0286   TH1F *hist_BadTSshape[5];         // 1d  histogramm for TS shape subdet -> test 41
0287   TH1F *hist_BadTSshape0[5];        // 1d  histogramm for TS shape subdet -> test 41
0288   TH1F *hist_ADC_All[5];            // 1d  histogramm for TS shape subdet -> test 42
0289   TH1F *hist_ADC_DS[5][ALLDEPTH];   // 1d  histogramm for TS shape subdet, depth -> test 42
0290   TH1F *hist_SumADC[5][ALLDEPTH];   // 1d  histogramm for TS shape subdet, depth -> test 43
0291   TH1F *hist_SumADC0[5][ALLDEPTH];  // 1d  histogramm for TS shape subdet, depth -> test 43
0292   TH1F *hist_SumADC1[5][ALLDEPTH];  // 1d  histogramm for TS shape subdet, depth -> test 43
0293 
0294   Map_SUB[1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1_HB");
0295   Map_SUB[1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2_HB");
0296   Map_SUB[2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1_HE");
0297   Map_SUB[2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2_HE");
0298   Map_SUB[2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3_HE");
0299   Map_SUB[3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4_HO");
0300   Map_SUB[4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1_HF");
0301   Map_SUB[4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2_HF");
0302 
0303   Map_SUB[1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3_HB");
0304   Map_SUB[1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4_HB");
0305   Map_SUB[2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4_HE");
0306   Map_SUB[2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5_HE");
0307   Map_SUB[2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6_HE");
0308   Map_SUB[2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7_HE");
0309   Map_SUB[4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3_HF");
0310   Map_SUB[4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4_HF");
0311 
0312   //+++++++++++++++++++++++++++++
0313   //Test 0 Entries
0314   //+++++++++++++++++++++++++++++
0315 
0316   for (int sub = 1; sub <= 4; sub++) {  //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
0317                                         //       if (sub==1) cHB->Divide(2,1);
0318     if (sub == 1)
0319       cHB->Divide(2, 2);
0320     //     if (sub==2) cHE->Divide(3,1);
0321     if (sub == 2)
0322       cHE->Divide(3, 3);
0323     if (sub == 3)
0324       cONE->Divide(1, 1);
0325     //     if (sub==4) cHF->Divide(2,1);
0326     if (sub == 4)
0327       cHF->Divide(2, 2);
0328     //       int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
0329     //     int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
0330     //       int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
0331     for (int k = k_min[sub]; k <= k_max[sub]; k++) {  //Depth
0332       if (sub == 1)
0333         cHB->cd(k);
0334       if (sub == 2)
0335         cHE->cd(k);
0336       if (sub == 3)
0337         cONE->cd(k - 3);
0338       if (sub == 4)
0339         cHF->cd(k);
0340       gPad->SetGridy();
0341       gPad->SetGridx();
0342       gPad->SetLogz();
0343       if (sub == 1)
0344         sprintf(str, "HB, Depth%d \b", k);
0345       if (sub == 2)
0346         sprintf(str, "HE, Depth%d \b", k);
0347       if (sub == 3)
0348         sprintf(str, "HO, Depth%d \b", k);
0349       if (sub == 4)
0350         sprintf(str, "HF, Depth%d \b", k);
0351       Map_SUB[sub][k]->SetTitle(str);
0352       Map_SUB[sub][k]->SetXTitle("#eta \b");
0353       Map_SUB[sub][k]->SetYTitle("#phi \b");
0354       Map_SUB[sub][k]->SetZTitle("Number of events \b");
0355       if (sub == 3)
0356         Map_SUB[sub][k]->SetTitleOffset(0.8, "Z");
0357       Map_SUB[sub][k]->Draw("COLZ");
0358       Map_SUB[sub][k]->GetYaxis()->SetRangeUser(0, 72.);
0359       //            Map_SUB[sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
0360       if (sub == 1) {
0361         cHB->Modified();
0362         cHB->Update();
0363       }
0364       if (sub == 2) {
0365         cHE->Modified();
0366         cHE->Update();
0367       }
0368       if (sub == 3) {
0369         cONE->Modified();
0370         cONE->Update();
0371       }
0372       if (sub == 4) {
0373         cHF->Modified();
0374         cHF->Update();
0375       }
0376     }  //end depth
0377 
0378     if (sub == 1) {
0379       cHB->Print("MapRateEntryHB.png");
0380       cHB->Clear();
0381     }
0382     if (sub == 2) {
0383       cHE->Print("MapRateEntryHE.png");
0384       cHE->Clear();
0385     }
0386     if (sub == 3) {
0387       cONE->Print("MapRateEntryHO.png");
0388       cONE->Clear();
0389     }
0390     if (sub == 4) {
0391       cHF->Print("MapRateEntryHF.png");
0392       cHF->Clear();
0393     }
0394   }  // end sub
0395 
0396   //+++++++++++++++++++++++++++++
0397   //Test 1 (Cm) Rate of Cap ID errors
0398   //+++++++++++++++++++++++++++++
0399 
0400   Map_Ampl[1][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Error_HB");
0401   Map_Ampl[1][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Error_HB");
0402   Map_Ampl[1][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Error_HE");
0403   Map_Ampl[1][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Error_HE");
0404   Map_Ampl[1][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Error_HE");
0405   Map_Ampl[1][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Error_HO");
0406   Map_Ampl[1][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Error_HF");
0407   Map_Ampl[1][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Error_HF");
0408 
0409   Map_Ampl[1][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Error_HB");
0410   Map_Ampl[1][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Error_HB");
0411   Map_Ampl[1][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Error_HE");
0412   Map_Ampl[1][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5Error_HE");
0413   Map_Ampl[1][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6Error_HE");
0414   Map_Ampl[1][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7Error_HE");
0415   Map_Ampl[1][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Error_HF");
0416   Map_Ampl[1][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Error_HF");
0417 
0418   for (int sub = 1; sub <= 4; sub++) {  //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
0419                                         //     if (sub==1) cHB->Divide(2,1);
0420     if (sub == 1)
0421       cHB->Divide(2, 2);
0422     //     if (sub==2) cHE->Divide(3,1);
0423     if (sub == 2)
0424       cHE->Divide(3, 3);
0425     if (sub == 3)
0426       cONE->Divide(1, 1);
0427     //     if (sub==4) cHF->Divide(2,1);
0428     if (sub == 4)
0429       cHF->Divide(2, 2);
0430     //       int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
0431     //     int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
0432     //       int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
0433     for (int k = k_min[sub]; k <= k_max[sub]; k++) {  //Depth
0434       if (sub == 1)
0435         cHB->cd(k);
0436       if (sub == 2)
0437         cHE->cd(k);
0438       if (sub == 3)
0439         cONE->cd(k - 3);
0440       if (sub == 4)
0441         cHF->cd(k);
0442       Map_Ampl[1][sub][k]->Divide(Map_Ampl[1][sub][k], Map_SUB[sub][k], 1, 1, "B");
0443       gPad->SetGridy();
0444       gPad->SetGridx();
0445       gPad->SetLogz();
0446       if (sub == 1)
0447         sprintf(str, "HB, Depth%d \b", k);
0448       if (sub == 2)
0449         sprintf(str, "HE, Depth%d \b", k);
0450       if (sub == 3)
0451         sprintf(str, "HO, Depth%d \b", k);
0452       if (sub == 4)
0453         sprintf(str, "HF, Depth%d \b", k);
0454       Map_Ampl[1][sub][k]->SetTitle(str);
0455       Map_Ampl[1][sub][k]->SetXTitle("#eta \b");
0456       Map_Ampl[1][sub][k]->SetYTitle("#phi \b");
0457       Map_Ampl[1][sub][k]->SetZTitle("Rate \b");
0458       if (sub == 3)
0459         Map_Ampl[1][sub][k]->SetTitleOffset(0.8, "Z");
0460       Map_Ampl[1][sub][k]->Draw("COLZ");
0461       Map_Ampl[1][sub][k]->GetYaxis()->SetRangeUser(0, 72.);
0462       Map_Ampl[1][sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
0463       if (sub == 1) {
0464         cHB->Modified();
0465         cHB->Update();
0466       }
0467       if (sub == 2) {
0468         cHE->Modified();
0469         cHE->Update();
0470       }
0471       if (sub == 3) {
0472         cONE->Modified();
0473         cONE->Update();
0474       }
0475       if (sub == 4) {
0476         cHF->Modified();
0477         cHF->Update();
0478       }
0479     }  //end depth
0480 
0481     if (sub == 1) {
0482       cHB->Print("MapRateCapIDHB.png");
0483       cHB->Clear();
0484     }
0485     if (sub == 2) {
0486       cHE->Print("MapRateCapIDHE.png");
0487       cHE->Clear();
0488     }
0489     if (sub == 3) {
0490       cONE->Print("MapRateCapIDHO.png");
0491       cONE->Clear();
0492     }
0493     if (sub == 4) {
0494       cHF->Print("MapRateCapIDHF.png");
0495       cHF->Clear();
0496     }
0497   }  // end sub
0498 
0499   //+++++++++++++++++++++++++++++
0500   //Test 2 (Am) ADC amplitude
0501   //+++++++++++++++++++++++++++++
0502 
0503   Map_Ampl[2][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1ADCAmpl225_HB");
0504   Map_Ampl[2][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2ADCAmpl225_HB");
0505   Map_Ampl[2][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1ADCAmpl225_HE");
0506   Map_Ampl[2][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2ADCAmpl225_HE");
0507   Map_Ampl[2][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3ADCAmpl225_HE");
0508   Map_Ampl[2][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4ADCAmpl225_HO");
0509   Map_Ampl[2][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1ADCAmpl225_HF");
0510   Map_Ampl[2][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2ADCAmpl225_HF");
0511 
0512   Map_Ampl[2][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3ADCAmpl225_HB");
0513   Map_Ampl[2][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4ADCAmpl225_HB");
0514   Map_Ampl[2][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4ADCAmpl225_HE");
0515   Map_Ampl[2][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5ADCAmpl225_HE");
0516   Map_Ampl[2][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6ADCAmpl225_HE");
0517   Map_Ampl[2][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7ADCAmpl225_HE");
0518   Map_Ampl[2][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3ADCAmpl225_HF");
0519   Map_Ampl[2][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4ADCAmpl225_HF");
0520 
0521   HistAmpl[2][1] = (TH1F *)dir->FindObjectAny("h_ADCAmpl_HB");
0522   HistAmpl[2][2] = (TH1F *)dir->FindObjectAny("h_ADCAmpl_HE");
0523   HistAmpl[2][3] = (TH1F *)dir->FindObjectAny("h_ADCAmpl_HO");
0524   HistAmpl[2][4] = (TH1F *)dir->FindObjectAny("h_ADCAmpl_HF");
0525 
0526   //+++++++++++++++++++++++++++++
0527   //Test 3 (Wm) Rate of RMS
0528   //+++++++++++++++++++++++++++++
0529 
0530   Map_Ampl[3][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Amplitude225_HB");
0531   Map_Ampl[3][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Amplitude225_HB");
0532   Map_Ampl[3][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Amplitude225_HE");
0533   Map_Ampl[3][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Amplitude225_HE");
0534   Map_Ampl[3][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Amplitude225_HE");
0535   Map_Ampl[3][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Amplitude225_HO");
0536   Map_Ampl[3][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Amplitude225_HF");
0537   Map_Ampl[3][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Amplitude225_HF");
0538 
0539   Map_Ampl[3][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Amplitude225_HB");
0540   Map_Ampl[3][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Amplitude225_HB");
0541   Map_Ampl[3][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Amplitude225_HE");
0542   Map_Ampl[3][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5Amplitude225_HE");
0543   Map_Ampl[3][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6Amplitude225_HE");
0544   Map_Ampl[3][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7Amplitude225_HE");
0545   Map_Ampl[3][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Amplitude225_HF");
0546   Map_Ampl[3][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Amplitude225_HF");
0547 
0548   HistAmpl[3][1] = (TH1F *)dir->FindObjectAny("h_Amplitude_HB");
0549   HistAmpl[3][2] = (TH1F *)dir->FindObjectAny("h_Amplitude_HE");
0550   HistAmpl[3][3] = (TH1F *)dir->FindObjectAny("h_Amplitude_HO");
0551   HistAmpl[3][4] = (TH1F *)dir->FindObjectAny("h_Amplitude_HF");
0552 
0553   //+++++++++++++++++++++++++++++
0554   //Test 4 (Rm) Rate of ratio 4 near max TS/ All TS
0555   //+++++++++++++++++++++++++++++
0556 
0557   Map_Ampl[4][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Ampl047_HB");
0558   Map_Ampl[4][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Ampl047_HB");
0559   Map_Ampl[4][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Ampl047_HE");
0560   Map_Ampl[4][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Ampl047_HE");
0561   Map_Ampl[4][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Ampl047_HE");
0562   Map_Ampl[4][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Ampl047_HO");
0563   Map_Ampl[4][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Ampl047_HF");
0564   Map_Ampl[4][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Ampl047_HF");
0565 
0566   Map_Ampl[4][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Ampl047_HB");
0567   Map_Ampl[4][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Ampl047_HB");
0568   Map_Ampl[4][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Ampl047_HE");
0569   Map_Ampl[4][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5Ampl047_HE");
0570   Map_Ampl[4][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6Ampl047_HE");
0571   Map_Ampl[4][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7Ampl047_HE");
0572   Map_Ampl[4][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Ampl047_HF");
0573   Map_Ampl[4][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Ampl047_HF");
0574 
0575   HistAmpl[4][1] = (TH1F *)dir->FindObjectAny("h_Ampl_HB");
0576   HistAmpl[4][2] = (TH1F *)dir->FindObjectAny("h_Ampl_HE");
0577   HistAmpl[4][3] = (TH1F *)dir->FindObjectAny("h_Ampl_HO");
0578   HistAmpl[4][4] = (TH1F *)dir->FindObjectAny("h_Ampl_HF");
0579 
0580   //+++++++++++++++++++++++++++++
0581   //Test 5 (TNm) Mean position in 1-8 TS range
0582   //+++++++++++++++++++++++++++++
0583 
0584   Map_Ampl[5][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TSmeanA225_HB");
0585   Map_Ampl[5][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TSmeanA225_HB");
0586   Map_Ampl[5][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TSmeanA225_HE");
0587   Map_Ampl[5][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TSmeanA225_HE");
0588   Map_Ampl[5][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TSmeanA225_HE");
0589   Map_Ampl[5][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmeanA225_HO");
0590   Map_Ampl[5][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TSmeanA225_HF");
0591   Map_Ampl[5][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TSmeanA225_HF");
0592 
0593   Map_Ampl[5][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TSmeanA225_HB");
0594   Map_Ampl[5][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmeanA225_HB");
0595   Map_Ampl[5][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmeanA225_HE");
0596   Map_Ampl[5][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5TSmeanA225_HE");
0597   Map_Ampl[5][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6TSmeanA225_HE");
0598   Map_Ampl[5][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7TSmeanA225_HE");
0599   Map_Ampl[5][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TSmeanA225_HF");
0600   Map_Ampl[5][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmeanA225_HF");
0601 
0602   HistAmpl[5][1] = (TH1F *)dir->FindObjectAny("h_TSmeanA_HB");
0603   HistAmpl[5][2] = (TH1F *)dir->FindObjectAny("h_TSmeanA_HE");
0604   HistAmpl[5][3] = (TH1F *)dir->FindObjectAny("h_TSmeanA_HO");
0605   HistAmpl[5][4] = (TH1F *)dir->FindObjectAny("h_TSmeanA_HF");
0606 
0607   //+++++++++++++++++++++++++++++
0608   //Test 6 (TXm) Maximum position in 1-8 TS range
0609   //+++++++++++++++++++++++++++++
0610 
0611   Map_Ampl[6][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TSmaxA225_HB");
0612   Map_Ampl[6][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TSmaxA225_HB");
0613   Map_Ampl[6][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TSmaxA225_HE");
0614   Map_Ampl[6][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TSmaxA225_HE");
0615   Map_Ampl[6][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TSmaxA225_HE");
0616   Map_Ampl[6][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmaxA225_HO");
0617   Map_Ampl[6][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TSmaxA225_HF");
0618   Map_Ampl[6][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TSmaxA225_HF");
0619 
0620   Map_Ampl[6][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TSmaxA225_HB");
0621   Map_Ampl[6][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmaxA225_HB");
0622   Map_Ampl[6][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmaxA225_HE");
0623   Map_Ampl[6][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5TSmaxA225_HE");
0624   Map_Ampl[6][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6TSmaxA225_HE");
0625   Map_Ampl[6][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7TSmaxA225_HE");
0626   Map_Ampl[6][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TSmaxA225_HF");
0627   Map_Ampl[6][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmaxA225_HF");
0628 
0629   HistAmpl[6][1] = (TH1F *)dir->FindObjectAny("h_TSmaxA_HB");
0630   HistAmpl[6][2] = (TH1F *)dir->FindObjectAny("h_TSmaxA_HE");
0631   HistAmpl[6][3] = (TH1F *)dir->FindObjectAny("h_TSmaxA_HO");
0632   HistAmpl[6][4] = (TH1F *)dir->FindObjectAny("h_TSmaxA_HF");
0633 
0634   for (int test = 2; test <= 6; test++) {  //Test: 2-Am, 3-Wm, 4-Rm, 5-TNm, 6-TXm,
0635     for (int sub = 1; sub <= 4; sub++) {   //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
0636                                            //        if (sub==1) cHB->Divide(2,1);
0637       if (sub == 1)
0638         cHB->Divide(2, 2);
0639       //        if (sub==2) cHE->Divide(3,1);
0640       if (sub == 2)
0641         cHE->Divide(3, 3);
0642       if (sub == 3)
0643         cONE->Divide(1, 1);
0644       //        if (sub==4) cHF->Divide(2,1);
0645       if (sub == 4)
0646         cHF->Divide(2, 2);
0647       //          int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
0648       //        int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
0649       //          int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
0650       for (int k = k_min[sub]; k <= k_max[sub]; k++) {  //Depth
0651         if (sub == 1)
0652           cHB->cd(k);
0653         if (sub == 2)
0654           cHE->cd(k);
0655         if (sub == 3)
0656           cONE->cd(k - 3);
0657         if (sub == 4)
0658           cHF->cd(k);
0659         Map_Ampl[test][sub][k]->Divide(Map_Ampl[test][sub][k], Map_SUB[sub][k], 1, 1, "B");
0660         gPad->SetGridy();
0661         gPad->SetGridx();
0662         gPad->SetLogz();
0663         if (sub == 1)
0664           sprintf(str, "HB, Depth%d \b", k);
0665         if (sub == 2)
0666           sprintf(str, "HE, Depth%d \b", k);
0667         if (sub == 3)
0668           sprintf(str, "HO, Depth%d \b", k);
0669         if (sub == 4)
0670           sprintf(str, "HF, Depth%d \b", k);
0671         Map_Ampl[test][sub][k]->SetTitle(str);
0672         Map_Ampl[test][sub][k]->SetXTitle("#eta \b");
0673         Map_Ampl[test][sub][k]->SetYTitle("#phi \b");
0674         Map_Ampl[test][sub][k]->SetZTitle("Rate \b");
0675         if (sub == 3)
0676           Map_Ampl[test][sub][k]->SetTitleOffset(0.8, "Z");
0677         Map_Ampl[test][sub][k]->Draw("COLZ");
0678         Map_Ampl[test][sub][k]->GetYaxis()->SetRangeUser(0, 72.);
0679         Map_Ampl[test][sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
0680         if (sub == 1) {
0681           cHB->Modified();
0682           cHB->Update();
0683         }
0684         if (sub == 2) {
0685           cHE->Modified();
0686           cHE->Update();
0687         }
0688         if (sub == 3) {
0689           cONE->Modified();
0690           cONE->Update();
0691         }
0692         if (sub == 4) {
0693           cHF->Modified();
0694           cHF->Update();
0695         }
0696       }  //end depth
0697       if (test == 2) {
0698         if (sub == 1) {
0699           cHB->Print("MapRateAmplHB.png");
0700           cHB->Clear();
0701         }
0702         if (sub == 2) {
0703           cHE->Print("MapRateAmplHE.png");
0704           cHE->Clear();
0705         }
0706         if (sub == 3) {
0707           cONE->Print("MapRateAmplHO.png");
0708           cONE->Clear();
0709         }
0710         if (sub == 4) {
0711           cHF->Print("MapRateAmplHF.png");
0712           cHF->Clear();
0713         }
0714       }
0715       if (test == 3) {
0716         if (sub == 1) {
0717           cHB->Print("MapRateRMSHB.png");
0718           cHB->Clear();
0719         }
0720         if (sub == 2) {
0721           cHE->Print("MapRateRMSHE.png");
0722           cHE->Clear();
0723         }
0724         if (sub == 3) {
0725           cONE->Print("MapRateRMSHO.png");
0726           cONE->Clear();
0727         }
0728         if (sub == 4) {
0729           cHF->Print("MapRateRMSHF.png");
0730           cHF->Clear();
0731         }
0732       }
0733       if (test == 4) {
0734         if (sub == 1) {
0735           cHB->Print("MapRate43TStoAllTSHB.png");
0736           cHB->Clear();
0737         }
0738         if (sub == 2) {
0739           cHE->Print("MapRate43TStoAllTSHE.png");
0740           cHE->Clear();
0741         }
0742         if (sub == 3) {
0743           cONE->Print("MapRate43TStoAllTSHO.png");
0744           cONE->Clear();
0745         }
0746         if (sub == 4) {
0747           cHF->Print("MapRate43TStoAllTSHF.png");
0748           cHF->Clear();
0749         }
0750       }
0751       if (test == 5) {
0752         if (sub == 1) {
0753           cHB->Print("MapRateMeanPosHB.png");
0754           cHB->Clear();
0755         }
0756         if (sub == 2) {
0757           cHE->Print("MapRateMeanPosHE.png");
0758           cHE->Clear();
0759         }
0760         if (sub == 3) {
0761           cONE->Print("MapRateMeanPosHO.png");
0762           cONE->Clear();
0763         }
0764         if (sub == 4) {
0765           cHF->Print("MapRateMeanPosHF.png");
0766           cHF->Clear();
0767         }
0768       }
0769       if (test == 6) {
0770         if (sub == 1) {
0771           cHB->Print("MapRateMaxPosHB.png");
0772           cHB->Clear();
0773         }
0774         if (sub == 2) {
0775           cHE->Print("MapRateMaxPosHE.png");
0776           cHE->Clear();
0777         }
0778         if (sub == 3) {
0779           cONE->Print("MapRateMaxPosHO.png");
0780           cONE->Clear();
0781         }
0782         if (sub == 4) {
0783           cHF->Print("MapRateMaxPosHF.png");
0784           cHF->Clear();
0785         }
0786       }
0787 
0788       //          cONE->Divide(1,1);
0789       cONE->Divide(3, 1);
0790       if (test == 2 && sub == 2) {
0791         cONE->cd(2);
0792         TH1F *kjkjkhj2 = (TH1F *)dir->FindObjectAny("h_AmplitudeHEtest1");
0793         kjkjkhj2->Draw("");
0794         kjkjkhj2->SetTitle("HE, All Depth: shunt1");
0795         cONE->cd(3);
0796         TH1F *kjkjkhj3 = (TH1F *)dir->FindObjectAny("h_AmplitudeHEtest6");
0797         kjkjkhj3->Draw("");
0798         kjkjkhj3->SetTitle("HE, All Depth: shunt6");
0799       }
0800       if (test == 2 && sub == 1) {
0801         cONE->cd(2);
0802         TH1F *kjkjkhb2 = (TH1F *)dir->FindObjectAny("h_AmplitudeHBtest1");
0803         kjkjkhb2->Draw("");
0804         kjkjkhb2->SetTitle("HB, All Depth: shunt1");
0805         cONE->cd(3);
0806         TH1F *kjkjkhb3 = (TH1F *)dir->FindObjectAny("h_AmplitudeHBtest6");
0807         kjkjkhb3->Draw("");
0808         kjkjkhb3->SetTitle("HB, All Depth: shunt6");
0809       }
0810       cONE->cd(1);
0811       gPad->SetGridy();
0812       gPad->SetGridx();
0813       gPad->SetLogy();
0814       if (sub == 1)
0815         HistAmpl[test][sub]->SetTitle("HB, All Depth: shunt6");
0816       if (sub == 2)
0817         HistAmpl[test][sub]->SetTitle("HE, All Depth: shunt6");
0818       if (sub == 3)
0819         HistAmpl[test][sub]->SetTitle("HO, All Depth");
0820       if (sub == 4)
0821         HistAmpl[test][sub]->SetTitle("HF, All Depth");
0822       if (test == 2)
0823         HistAmpl[test][sub]->SetXTitle("ADC Amlitude in each event & cell \b");
0824       if (test == 3)
0825         HistAmpl[test][sub]->SetXTitle("RMS in each event & cell \b");
0826       if (test == 4)
0827         HistAmpl[test][sub]->SetXTitle("Ratio in each event & cell \b");
0828       if (test == 5)
0829         HistAmpl[test][sub]->SetXTitle("Mean TS position in each event & cell \b");
0830       if (test == 6)
0831         HistAmpl[test][sub]->SetXTitle("Max TS position in each event & cell \b");
0832       HistAmpl[test][sub]->SetYTitle("Number of cell-events \b");
0833       HistAmpl[test][sub]->SetLineColor(4);
0834       HistAmpl[test][sub]->SetLineWidth(2);
0835       HistAmpl[test][sub]->SetTitleOffset(1.4, "Y");
0836       HistAmpl[test][sub]->Draw("");
0837       // //        HistAmpl[test][sub]->GetYaxis()->SetRangeUser(1., 100.);
0838       //          if (test==2) {gPad->SetLogx(); HistAmpl[test][sub]->GetXaxis()->SetRangeUser(1., 10000.);}
0839       if (test == 2) {
0840         gPad->SetLogx();
0841       }
0842       if (test == 3)
0843         HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 5.);  // width
0844       if (test == 4)
0845         HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 1.);  // R
0846       if (test == 5)
0847         HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 9.);  //Tn
0848       if (test == 6)
0849         HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 9.);  //Tx
0850       cONE->Modified();
0851       cONE->Update();
0852       double min_x[] = {MIN_M[test][sub], MIN_M[test][sub]};
0853       double min_y[] = {0., 100000000.};
0854       TGraph *MIN = new TGraph(2, min_x, min_y);
0855       MIN->SetLineStyle(2);
0856       MIN->SetLineColor(2);
0857       MIN->SetLineWidth(2 + 100 * 100);
0858       MIN->SetFillStyle(3005);
0859       MIN->SetFillColor(2);
0860       MIN->Draw("L");
0861       double max_x[] = {MAX_M[test][sub], MAX_M[test][sub]};
0862       double max_y[] = {0., 100000000.};
0863       TGraph *MAX = new TGraph(2, max_x, max_y);
0864       MAX->SetLineStyle(2);
0865       MAX->SetLineColor(2);
0866       MAX->SetLineWidth(-2 - 100 * 100);
0867       MAX->SetFillStyle(3004);
0868       MAX->SetFillColor(2);
0869       MAX->Draw("L");
0870       if (test == 2) {
0871         if (sub == 1) {
0872           cONE->Print("HistAmplHB.png");
0873           cONE->Clear();
0874         }
0875         if (sub == 2) {
0876           cONE->Print("HistAmplHE.png");
0877           cONE->Clear();
0878         }
0879         if (sub == 3) {
0880           cONE->Print("HistAmplHO.png");
0881           cONE->Clear();
0882         }
0883         if (sub == 4) {
0884           cONE->Print("HistAmplHF.png");
0885           cONE->Clear();
0886         }
0887       }
0888       if (test == 3) {
0889         if (sub == 1) {
0890           cONE->Print("HistRMSHB.png");
0891           cONE->Clear();
0892         }
0893         if (sub == 2) {
0894           cONE->Print("HistRMSHE.png");
0895           cONE->Clear();
0896         }
0897         if (sub == 3) {
0898           cONE->Print("HistRMSHO.png");
0899           cONE->Clear();
0900         }
0901         if (sub == 4) {
0902           cONE->Print("HistRMSHF.png");
0903           cONE->Clear();
0904         }
0905       }
0906       if (test == 4) {
0907         if (sub == 1) {
0908           cONE->Print("Hist43TStoAllTSHB.png");
0909           cONE->Clear();
0910         }
0911         if (sub == 2) {
0912           cONE->Print("Hist43TStoAllTSHE.png");
0913           cONE->Clear();
0914         }
0915         if (sub == 3) {
0916           cONE->Print("Hist43TStoAllTSHO.png");
0917           cONE->Clear();
0918         }
0919         if (sub == 4) {
0920           cONE->Print("Hist43TStoAllTSHF.png");
0921           cONE->Clear();
0922         }
0923       }
0924       if (test == 5) {
0925         if (sub == 1) {
0926           cONE->Print("HistMeanPosHB.png");
0927           cONE->Clear();
0928         }
0929         if (sub == 2) {
0930           cONE->Print("HistMeanPosHE.png");
0931           cONE->Clear();
0932         }
0933         if (sub == 3) {
0934           cONE->Print("HistMeanPosHO.png");
0935           cONE->Clear();
0936         }
0937         if (sub == 4) {
0938           cONE->Print("HistMeanPosHF.png");
0939           cONE->Clear();
0940         }
0941       }
0942       if (test == 6) {
0943         if (sub == 1) {
0944           cONE->Print("HistMaxPosHB.png");
0945           cONE->Clear();
0946         }
0947         if (sub == 2) {
0948           cONE->Print("HistMaxPosHE.png");
0949           cONE->Clear();
0950         }
0951         if (sub == 3) {
0952           cONE->Print("HistMaxPosHO.png");
0953           cONE->Clear();
0954         }
0955         if (sub == 4) {
0956           cONE->Print("HistMaxPosHF.png");
0957           cONE->Clear();
0958         }
0959       }
0960     }  // end sub
0961   }    //end test
0962 
0963   TH2F *Map_Calib[5][5];  // 2d histogramm for subdet, depth
0964 
0965   Map_Calib[1][1] = (TH2F *)dir->FindObjectAny("h_map_HB");
0966   Map_Calib[1][2] = (TH2F *)dir->FindObjectAny("h_map_HB");
0967   Map_Calib[2][1] = (TH2F *)dir->FindObjectAny("h_map_HE");
0968   Map_Calib[2][2] = (TH2F *)dir->FindObjectAny("h_map_HE");
0969   Map_Calib[2][3] = (TH2F *)dir->FindObjectAny("h_map_HE");
0970   Map_Calib[3][4] = (TH2F *)dir->FindObjectAny("h_map_HO");
0971   Map_Calib[4][1] = (TH2F *)dir->FindObjectAny("h_map_HF");
0972   Map_Calib[4][2] = (TH2F *)dir->FindObjectAny("h_map_HF");
0973 
0974   //+++++++++++++++++++++++++++++
0975   //Test 0 Entries
0976   //+++++++++++++++++++++++++++++
0977 
0978   for (int sub = 1; sub <= 4; sub++) {  //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
0979                                         //       if (sub==1) cHB->Divide(2,1);
0980                                         //       if (sub==2) cHE->Divide(3,1);
0981     cONE->Divide(1, 1);
0982     //      if (sub==4) cHB->Divide(2,1);
0983     //       int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
0984     //       int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
0985     //       for (int k=k_min[sub];k<=k_max[sub];k++) {  //Depth
0986     int k = 1;
0987     cONE->cd(k);
0988     //          if (sub==1) cHB->cd(k);
0989     //          if (sub==2) cHE->cd(k);
0990     if (sub == 3)
0991       k = 4;
0992     //      if (sub==4) cHB->cd(k);
0993     gPad->SetGridy();
0994     gPad->SetGridx();
0995     gPad->SetLogz();
0996     if (sub == 1)
0997       sprintf(str, "HB");
0998     if (sub == 2)
0999       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     }
1819     ////////////////////////////////////////////////////////////////////////////////////
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 
2089       ///////////////////////////////////////////////
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 
2345   //////////////////////////////////////////////////////////////
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 
2427   //////////////////////////////////////////////////////////////////////////////////////////////////////
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 
2657   /////////////  /////////////  /////////////  /////////////  /////////////  ////////////////////         phi-symmetry for Calibration Group:
2658   /////////////  /////////////  /////////////  ////////////  /////////////  /////////////////////         Phi-symmetry for Calibration Group:
2659   /////////////  /////////////  /////////////  ////////////  /////////////  /////////////////////         Phi-symmetry for Calibration Group:
2660   /////////////  /////////////  /////////////  ///////////  /////////////  //////////////////////         Phi-symmetry for Calibration Group:
2661   /////////////  /////////////  /////////////  ///////////  /////////////  //////////////////////         Phi-symmetry for Calibration Group:
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;
2684   /////////////   ///////////// //////////////////////////  /////////////  /////////////  /////////////  /////////////  /////////////  ////////////////////         Phi-symmetry for Calibration Group:
2685   /////////////  /////////////  //////////////////////////  /////////////  /////////////  /////////////  /////////////  ////////////////////         Phi-symmetry for Calibration Group:
2686   /////////////  /////////////  /////////////  /////////////  /////////////  /////////////  /////////////  ////////////////////         Phi-symmetry for Calibration Group:
2687 
2688   //////////////////////////////////////////////////////////////////////////////////////////////////// Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi
2689   //////////////////////////////////////////////////////////////////////////////////////////////////// Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi
2690   //////////////////////////////////////////////////////////////////////////////////////////////////// Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi
2691   //////////////////////////////////////////////////////////////////////////////////////////////////// Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi  Digi
2692 
2693   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Digi HB
2694   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Digi HB
2695   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Digi HB
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();
2768   /////////////////
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");
2800   /////////////////
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();
2815   /////////////////
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");
2847   /////////////////
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();
2863   /////////////////
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
2936   /////////////////
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();
2949   /////////////////
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
3022   /////////////////
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();
3034   /////////////////
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
3107   /////////////////
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();
3119   /////////////////
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
3194   /////////////////
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();
3207   /////////////////
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
3280   /////////////////
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();
3293   /////////////////
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
3366   /////////////////
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();
3378   /////////////////
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
3452   /////////////////
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();
3464   /////////////////
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
3539   /////////////////
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();
3634   /////////////////
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");
3667   /////////////////
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();
3682   /////////////////
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");
3716   /////////////////
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();
3733   /////////////////
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
3808   /////////////////
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
3894   /////////////////
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
3980   /////////////////
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
4066   /////////////////
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();
4079   /////////////////
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
4154   /////////////////
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
4240   /////////////////
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
4326   /////////////////
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
4412   /////////////////
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 
4424   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Digi HE
4425   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Digi HE
4426   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Digi HE
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();
4539   /////////////////
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");
4571   /////////////////
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();
4586   /////////////////
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");
4618   /////////////////
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();
4635   /////////////////
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
4700   /////////////////
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();
4713   /////////////////
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
4780   /////////////////
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();
4792   /////////////////
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
4859   /////////////////
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();
4871   /////////////////
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
4938   /////////////////
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();
4950   /////////////////
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
5017   /////////////////
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();
5029   /////////////////
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
5092   /////////////////
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();
5104   /////////////////
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
5153   /////////////////
5154   c3x5->Update();
5155   c3x5->Print("RdigiPositiveDirectionhistD1PhiSymmetryDepth7HE.png");
5156   c3x5->Clear();
5157   // clean-up
5158   if (h2CeffHEpositivedirectionDigi7)
5159     delete h2CeffHEpositivedirectionDigi7;
5160 
5161   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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();
5167   /////////////////
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
5232   /////////////////
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();
5245   /////////////////
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
5312   /////////////////
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();
5324   /////////////////
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
5391   /////////////////
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();
5403   /////////////////
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
5470   /////////////////
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();
5482   /////////////////
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
5549   /////////////////
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();
5561   /////////////////
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
5624   /////////////////
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();
5636   /////////////////
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
5685   /////////////////
5686   c3x5->Update();
5687   c3x5->Print("RdigiNegativeDirectionhistD1PhiSymmetryDepth7HE.png");
5688   c3x5->Clear();
5689   // clean-up
5690   if (h2CeffHEnegativedirectionDigi7)
5691     delete h2CeffHEnegativedirectionDigi7;
5692 
5693   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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();
5824   /////////////////
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");
5857   /////////////////
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();
5872   /////////////////
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");
5906   /////////////////
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();
5922   /////////////////
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
5989   /////////////////
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
6069   /////////////////
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
6149   /////////////////
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
6227   /////////////////
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
6303   /////////////////
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
6377   /////////////////
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
6437   /////////////////
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();
6450   /////////////////
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
6517   /////////////////
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
6597   /////////////////
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
6677   /////////////////
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
6755   /////////////////
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
6831   /////////////////
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
6905   /////////////////
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
6965   /////////////////
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 
6976   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Digi HF
6977   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Digi HF
6978   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Digi HF
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();
7051   /////////////////
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");
7083   /////////////////
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();
7098   /////////////////
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");
7130   /////////////////
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();
7146   /////////////////
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
7213   /////////////////
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();
7226   /////////////////
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
7293   /////////////////
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();
7305   /////////////////
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
7372   /////////////////
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();
7384   /////////////////
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
7453   /////////////////
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();
7466   /////////////////
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
7533   /////////////////
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();
7546   /////////////////
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
7613   /////////////////
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();
7625   /////////////////
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
7692   /////////////////
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();
7704   /////////////////
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
7773   /////////////////
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();
7868   /////////////////
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");
7901   /////////////////
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();
7916   /////////////////
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");
7950   /////////////////
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();
7966   /////////////////
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
8035   /////////////////
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
8115   /////////////////
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
8195   /////////////////
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
8275   /////////////////
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();
8288   /////////////////
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
8357   /////////////////
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
8437   /////////////////
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
8517   /////////////////
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
8597   /////////////////
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 
8625   ////////////////////// Start   Recosignal  Start Recosignal  Start   Recosignal  Start   Recosignal  Start   Recosignal Start  Recosignal Start Recosignal Start Recosignal Start Recosignal Start Recosignal Start
8626   ////////////////////// Start   Recosignal  Start Recosignal  Start   Recosignal  Start   Recosignal  Start   Recosignal Start  Recosignal Start Recosignal Start Recosignal Start Recosignal Start Recosignal Start
8627   ////////////////////// Start   Recosignal  Start Recosignal  Start   Recosignal  Start   Recosignal  Start   Recosignal Start  Recosignal Start Recosignal Start Recosignal Start Recosignal Start Recosignal Start
8628 
8629   ////////////////////////////////////////////////////////////////////////////////////////////////////     Recosignal HB
8630   ////////////////////////////////////////////////////////////////////////////////////////////////////     Recosignal HB
8631   ////////////////////////////////////////////////////////////////////////////////////////////////////     Recosignal HB
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();
8704   /////////////////
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 
8742   /////////////////
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();
8757   /////////////////
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");
8790   /////////////////
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();
8806   /////////////////
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
8879   /////////////////
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();
8892   /////////////////
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
8965   /////////////////
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();
8977   /////////////////
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
9050   /////////////////
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();
9062   /////////////////
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
9137   /////////////////
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();
9150   /////////////////
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
9223   /////////////////
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();
9236   /////////////////
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
9309   /////////////////
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();
9321   /////////////////
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
9395   /////////////////
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();
9407   /////////////////
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
9482   /////////////////
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();
9577   /////////////////
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");
9610   /////////////////
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();
9625   /////////////////
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");
9661   /////////////////
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();
9678   /////////////////
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
9753   /////////////////
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
9839   /////////////////
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
9925   /////////////////
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
10011   /////////////////
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();
10024   /////////////////
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
10099   /////////////////
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
10185   /////////////////
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
10271   /////////////////
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
10357   /////////////////
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 
10369   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Recosignal HE
10370   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Recosignal HE
10371   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Recosignal HE
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();
10484   /////////////////
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 
10522   /////////////////
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();
10537   /////////////////
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");
10570   /////////////////
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();
10587   /////////////////
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
10652   /////////////////
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();
10665   /////////////////
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
10732   /////////////////
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();
10744   /////////////////
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
10811   /////////////////
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();
10823   /////////////////
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
10890   /////////////////
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();
10902   /////////////////
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
10969   /////////////////
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();
10981   /////////////////
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
11044   /////////////////
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();
11056   /////////////////
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
11105   /////////////////
11106   c3x5->Update();
11107   c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth7HE.png");
11108   c3x5->Clear();
11109   // clean-up
11110   if (h2CeffHEpositivedirectionRecosignal7)
11111     delete h2CeffHEpositivedirectionRecosignal7;
11112 
11113   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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();
11119   /////////////////
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
11184   /////////////////
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();
11197   /////////////////
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
11264   /////////////////
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();
11276   /////////////////
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
11343   /////////////////
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();
11355   /////////////////
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
11422   /////////////////
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();
11434   /////////////////
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
11501   /////////////////
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();
11513   /////////////////
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
11576   /////////////////
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();
11588   /////////////////
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
11637   /////////////////
11638   c3x5->Update();
11639   c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth7HE.png");
11640   c3x5->Clear();
11641   // clean-up
11642   if (h2CeffHEnegativedirectionRecosignal7)
11643     delete h2CeffHEnegativedirectionRecosignal7;
11644 
11645   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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();
11776   /////////////////
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");
11809   /////////////////
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();
11824   /////////////////
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");
11860   /////////////////
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();
11876   /////////////////
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
11943   /////////////////
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
12023   /////////////////
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
12103   /////////////////
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
12181   /////////////////
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
12257   /////////////////
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
12331   /////////////////
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
12391   /////////////////
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();
12404   /////////////////
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
12471   /////////////////
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
12551   /////////////////
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
12631   /////////////////
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
12709   /////////////////
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
12785   /////////////////
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
12859   /////////////////
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
12919   /////////////////
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
12929   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Recosignal HF
12930   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Recosignal HF
12931   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Recosignal HF
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();
12980   /////////////////
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 
13018   /////////////////
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();
13033   /////////////////
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");
13066   /////////////////
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();
13082   /////////////////
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
13149   /////////////////
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();
13162   /////////////////
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
13229   /////////////////
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();
13242   /////////////////
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
13309   /////////////////
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();
13322   /////////////////
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
13389   /////////////////
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();
13454   /////////////////
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");
13487   /////////////////
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();
13502   /////////////////
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");
13538   /////////////////
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();
13554   /////////////////
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
13623   /////////////////
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
13703   /////////////////
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();
13715   /////////////////
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
13784   /////////////////
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
13864   /////////////////
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 
13879   ////////////////////// Start   Reconoise  Start Reconoise  Start   Reconoise  Start   Reconoise  Start   Reconoise Start  Reconoise Start Reconoise Start Reconoise Start Reconoise Start Reconoise Start
13880   ////////////////////// Start   Reconoise  Start Reconoise  Start   Reconoise  Start   Reconoise  Start   Reconoise Start  Reconoise Start Reconoise Start Reconoise Start Reconoise Start Reconoise Start
13881   ////////////////////// Start   Reconoise  Start Reconoise  Start   Reconoise  Start   Reconoise  Start   Reconoise Start  Reconoise Start Reconoise Start Reconoise Start Reconoise Start Reconoise Start
13882   ////////////////////////////////////////////////////////////////////////////////////////////////////     Reconoise HB
13883   ////////////////////////////////////////////////////////////////////////////////////////////////////     Reconoise HB
13884   ////////////////////////////////////////////////////////////////////////////////////////////////////     Reconoise HB
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();
13975   /////////////////
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 
14015   /////////////////
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();
14030   /////////////////
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");
14064   /////////////////
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();
14080   /////////////////
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
14153   /////////////////
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();
14166   /////////////////
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
14239   /////////////////
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();
14251   /////////////////
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
14324   /////////////////
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();
14336   /////////////////
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
14411   /////////////////
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();
14424   /////////////////
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
14497   /////////////////
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();
14510   /////////////////
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
14583   /////////////////
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();
14595   /////////////////
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
14669   /////////////////
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();
14681   /////////////////
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
14756   /////////////////
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();
14770   /////////////////
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 
14802   /////////////////
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();
14817   /////////////////
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");
14852   /////////////////
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();
14868   /////////////////
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
14941   /////////////////
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();
14954   /////////////////
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
15027   /////////////////
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();
15039   /////////////////
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
15112   /////////////////
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();
15124   /////////////////
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
15199   /////////////////
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();
15212   /////////////////
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
15285   /////////////////
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();
15298   /////////////////
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
15371   /////////////////
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();
15383   /////////////////
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
15457   /////////////////
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();
15469   /////////////////
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
15544   /////////////////
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();
15641   /////////////////
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");
15676   /////////////////
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();
15691   /////////////////
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");
15728   /////////////////
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();
15745   /////////////////
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
15820   /////////////////
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
15906   /////////////////
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
15992   /////////////////
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
16078   /////////////////
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();
16091   /////////////////
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
16166   /////////////////
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
16252   /////////////////
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
16338   /////////////////
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
16424   /////////////////
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 
16436   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Reconoise HE
16437   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Reconoise HE
16438   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Reconoise HE
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];
16446   ////////////////////////////////////////////////////////////////////////////////////////////////////////////
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();
16582   /////////////////
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 
16622   /////////////////
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();
16637   /////////////////
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");
16671   /////////////////
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();
16688   /////////////////
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
16753   /////////////////
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();
16766   /////////////////
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
16833   /////////////////
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();
16845   /////////////////
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
16912   /////////////////
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();
16924   /////////////////
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
16991   /////////////////
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();
17003   /////////////////
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
17070   /////////////////
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();
17082   /////////////////
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
17145   /////////////////
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();
17157   /////////////////
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
17206   /////////////////
17207   c3x5->Update();
17208   c3x5->Print("RreconoisePositiveDirectionhistD1PhiSymmetryDepth7HE.png");
17209   c3x5->Clear();
17210   // clean-up
17211   if (h2CeffHEpositivedirectionReconoise7)
17212     delete h2CeffHEpositivedirectionReconoise7;
17213 
17214   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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();
17220   /////////////////
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
17285   /////////////////
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();
17298   /////////////////
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
17365   /////////////////
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();
17377   /////////////////
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
17444   /////////////////
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();
17456   /////////////////
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
17523   /////////////////
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();
17535   /////////////////
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
17602   /////////////////
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();
17614   /////////////////
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
17677   /////////////////
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();
17689   /////////////////
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
17738   /////////////////
17739   c3x5->Update();
17740   c3x5->Print("RreconoiseNegativeDirectionhistD1PhiSymmetryDepth7HE.png");
17741   c3x5->Clear();
17742   // clean-up
17743   if (h2CeffHEnegativedirectionReconoise7)
17744     delete h2CeffHEnegativedirectionReconoise7;
17745 
17746   //======================================================================================================================
17747   //======================================================================================================================
17748   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
17749   //======================================================================================================================
17750   //                                   DIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIF:   Reconoise HE
17751   //======================================================================================================================
17752   //======================================================================
17753   c2x1->Clear();
17754   /////////////////
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 
17786   /////////////////
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();
17801   /////////////////
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");
17836   /////////////////
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();
17853   /////////////////
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
17918   /////////////////
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();
17931   /////////////////
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
17998   /////////////////
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();
18010   /////////////////
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
18077   /////////////////
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();
18089   /////////////////
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
18156   /////////////////
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();
18168   /////////////////
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
18235   /////////////////
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();
18247   /////////////////
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
18310   /////////////////
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();
18322   /////////////////
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
18371   /////////////////
18372   c3x5->Update();
18373   c3x5->Print("DIFreconoisePositiveDirectionhistD1PhiSymmetryDepth7HE.png");
18374   c3x5->Clear();
18375   // clean-up
18376   if (h2CeffHEpositivedirectionReconoiseDIF7)
18377     delete h2CeffHEpositivedirectionReconoiseDIF7;
18378 
18379   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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();
18385   /////////////////
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
18450   /////////////////
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();
18463   /////////////////
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
18530   /////////////////
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();
18542   /////////////////
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
18609   /////////////////
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();
18621   /////////////////
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
18688   /////////////////
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();
18700   /////////////////
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
18767   /////////////////
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();
18779   /////////////////
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
18842   /////////////////
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();
18854   /////////////////
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
18903   /////////////////
18904   c3x5->Update();
18905   c3x5->Print("DIFreconoiseNegativeDirectionhistD1PhiSymmetryDepth7HE.png");
18906   c3x5->Clear();
18907   // clean-up
18908   if (h2CeffHEnegativedirectionReconoiseDIF7)
18909     delete h2CeffHEnegativedirectionReconoiseDIF7;
18910 
18911   //======================================================================================================================
18912   //======================================================================================================================
18913   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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();
19049   /////////////////
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");
19084   /////////////////
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();
19099   /////////////////
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");
19136   /////////////////
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();
19152   /////////////////
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
19219   /////////////////
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
19299   /////////////////
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
19379   /////////////////
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
19457   /////////////////
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
19533   /////////////////
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
19607   /////////////////
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
19667   /////////////////
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();
19680   /////////////////
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
19747   /////////////////
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
19827   /////////////////
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
19907   /////////////////
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
19985   /////////////////
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
20061   /////////////////
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
20135   /////////////////
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
20195   /////////////////
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
20205   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Reconoise HF
20206   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Reconoise HF
20207   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Reconoise HF
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
20260   /////////////////////////////////////////
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();
20268   /////////////////
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 
20308   /////////////////
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();
20323   /////////////////
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");
20357   /////////////////
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();
20373   /////////////////
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
20440   /////////////////
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();
20453   /////////////////
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
20520   /////////////////
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();
20533   /////////////////
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
20600   /////////////////
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();
20613   /////////////////
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
20680   /////////////////
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();
20695   /////////////////
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 
20727   /////////////////
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();
20742   /////////////////
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");
20777   /////////////////
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();
20793   /////////////////
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
20860   /////////////////
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();
20873   /////////////////
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
20940   /////////////////
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();
20953   /////////////////
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
21020   /////////////////
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();
21033   /////////////////
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
21100   /////////////////
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();
21167   /////////////////
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");
21202   /////////////////
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();
21217   /////////////////
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");
21254   /////////////////
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();
21270   /////////////////
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
21339   /////////////////
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
21419   /////////////////
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();
21431   /////////////////
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
21500   /////////////////
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
21580   /////////////////
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   //======================================================================
21604   /// Prepare maps of good/bad channels:
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 
21838   /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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 
21905   /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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 
22669     ///////////////////////////////////////////
22670 
22671     //////////////////////////////////////////////////////////////////////////////////////////////////// Phi-symmetry for Calibration Group:
22672 
22673     ///////////////////////////////////////////////////////////////////////////////////////////////////////// Digis
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 
22692     /////////////////////////////////////////////// RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
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 
22723     ///////////////////////////////////////////   PositiveDirection:
22724 
22725     /////////////////////////////////////////////// R different Depthes:
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 
22788     /////////////////////////////////////////////// DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
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 
22810     ///////////////////////////////////////////   PositiveDirection:
22811     ///////////////////////////////////////////////D  different Depthes:
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 
22874     ///////////////////////////////////////////   NegativeDirection:
22875     /////////////////////////////////////////////// RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
22876     htmlFileM << "<h2> 3:  Negative direction, R = R_depth_ieta_iphi = E_depth_ieta_iphi/E_depth_ieta </h3>"
22877               << std::endl;
22878 
22879     /////////////////////////////////////////////// different Depthes:
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 
22941     /////////////////////////////////////////////// DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
22942     htmlFileM << "<h2> 4: Negative direction,   D(digivarianceSignalhe)   </h3>" << std::endl;
22943     /////////////////////////////////////////////// different Depthes:
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;
23004     ///////////////////////////////////////////
23005     htmlFileM.close();
23006     /////////////////////////////////////////// end of Digi
23007     //
23008     ////////////////////////////////////////////////////////////////////////////////////////////// RecoSignal:
23009     ////////////////////////////////////////////////////////////////////////////////////////////// RecoSignal:
23010     ////////////////////////////////////////////////////////////////////////////////////////////// RecoSignal:
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 
23029     /////////////////////////////////////////////// RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
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 
23063     ///////////////////////////////////////////   PositiveDirection:
23064 
23065     /////////////////////////////////////////////// R different Depthes:
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 
23126     /////////////////////////////////////////////// DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
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 
23148     ///////////////////////////////////////////   PositiveDirection:
23149     ///////////////////////////////////////////////D  different Depthes:
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 
23210     ///////////////////////////////////////////   NegativeDirection:
23211     /////////////////////////////////////////////// RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
23212     htmlFileR << "<h2> 3:  Negative direction, R = R_depth_ieta_iphi = E_depth_ieta_iphi/E_depth_ieta </h3>"
23213               << std::endl;
23214 
23215     /////////////////////////////////////////////// different Depthes:
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 
23275     /////////////////////////////////////////////// DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
23276     htmlFileR << "<h2> 4: Negative direction,   D(recosignalvarianceSignalhe)   </h3>" << std::endl;
23277     /////////////////////////////////////////////// different Depthes:
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;
23336     ///////////////////////////////////////////
23337     htmlFileR.close();
23338     /////////////////////////////////////////// end of Recosignal
23339     //
23340     ////////////////////////////////////////////////////////////////////////////////////////////// RecoNoise:
23341     ////////////////////////////////////////////////////////////////////////////////////////////// RecoNoise:
23342     ////////////////////////////////////////////////////////////////////////////////////////////// RecoNoise:
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 
23361     /////////////////////////////////////////////// RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
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 
23395     ///////////////////////////////////////////   PositiveDirection:
23396 
23397     /////////////////////////////////////////////// R different Depthes:
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 
23458     /////////////////////////////////////////////// DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
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 
23480     ///////////////////////////////////////////   PositiveDirection:
23481     ///////////////////////////////////////////////D  different Depthes:
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 
23542     ///////////////////////////////////////////   NegativeDirection:
23543     /////////////////////////////////////////////// RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
23544     htmlFileN << "<h2> 3:  Negative direction, R = R_depth_ieta_iphi = E_depth_ieta_iphi/E_depth_ieta </h3>"
23545               << std::endl;
23546 
23547     /////////////////////////////////////////////// different Depthes:
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 
23607     /////////////////////////////////////////////// DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
23608     htmlFileN << "<h2> 4: Negative direction,   D(reconoisevarianceNoisehe)   </h3>" << std::endl;
23609     /////////////////////////////////////////////// different Depthes:
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;
23668     ///////////////////////////////////////////
23669 
23670     /////////////////////////////////////////////// DIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIFDIF
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 
23701     /////////////////////////////////////////// DIF  PositiveDirection:
23702 
23703     /////////////////////////////////////////////// DIF different Depthes:
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 
23765     /////////////////////////////////////////// DIF  NegativeDirection:
23766 
23767     /////////////////////////////////////////////// DIF different Depthes:
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 
23829     /////////////////////////////////////////// end of Reconoise
23830 
23831     //
23832     //
23833     htmlFileN.close();
23834 
23835     /////////////////////////////////////////// end of Reconoise
23836     /////////////////////////////////////////// end of Reconoise
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 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!