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 (