Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2022-03-08 02:26:18

0001 // How to run: ./RemoteMonitoringALCARECOPSM.cc.exe root_file1  root_file_ref Global
0002 //
0003 //
0004 //
0005 //
0006 
0007 #include "LogEleMapdb.h"
0008 
0009 #include <iostream>
0010 #include <fstream>
0011 
0012 #include "TH1.h"
0013 #include "TH2.h"
0014 #include "TCanvas.h"
0015 #include "TROOT.h"
0016 #include <TMath.h>
0017 #include "TStyle.h"
0018 #include "TSystem.h"
0019 #include "TLegend.h"
0020 #include "TText.h"
0021 #include "TAxis.h"
0022 #include "TFile.h"
0023 #include "TLine.h"
0024 #include "TGraph.h"
0025 
0026 using namespace std;
0027 int main(int argc, char* argv[]) {
0028   std::string dirnm = "Analyzer";
0029   gROOT->Reset();
0030   gROOT->SetStyle("Plain");
0031   gStyle->SetOptStat(0);
0032   gStyle->SetOptTitle(1);
0033   // ok change
0034   if (argc < 3)
0035     return 1;
0036   char fname[300];
0037   char refname[300];
0038   char runtypeC[300];
0039   sprintf(fname, "%s", argv[1]);
0040   sprintf(refname, "%s", argv[2]);
0041   sprintf(runtypeC, "%s", argv[3]);
0042   //               std::cout<<fname<<" "<<refname<<" "<<runtypeC<<std::endl;
0043   std::cout << " We are here to print fname refname runtypeC " << fname << " " << refname << " " << runtypeC
0044             << std::endl;
0045   // ok change
0046 
0047   //======================================================================
0048   // Connect the input files, parameters and get the 2-d histogram in memory
0049   string promt = (string)fname;
0050   string runtype = (string)runtypeC;
0051   string runnumber = "";
0052   for (unsigned int i = promt.size() - 11; i < promt.size() - 5; i++)
0053     runnumber += fname[i];
0054 
0055   TFile* hfile = new TFile(fname, "READ");
0056   hfile->ls();
0057   TDirectory* dir = (TDirectory*)hfile->FindObjectAny(dirnm.c_str());
0058 
0059   // with TfileService implementation, change everywhere below:     hfile->Get     to     dir->FindObjectAny
0060 
0061   //======================================================================
0062   // Prepare histograms and plot them to .png files
0063 
0064   // Phi-symmetry for Calibration Group:
0065 
0066   TCanvas* c1x0 = new TCanvas("c1x0", "c1x0", 300, 10, 800, 700);
0067 
0068   TCanvas* c1x1 = new TCanvas("c1x1", "c1x1", 100, 10, 600, 700);
0069 
0070   TCanvas* c2x1 = new TCanvas("c2x1", "c2x1", 200, 300, 1600, 800);
0071 
0072   TCanvas* c3x5 = new TCanvas("c3x5", "c3x5", 1000, 1500);
0073   //
0074 
0075   char* str = (char*)alloca(10000);
0076 
0077   // before upgrade 2017:
0078   // depth: HB depth1,2; HE depth1,2,3; HO depth4; HF depth1,2
0079   // 5 depthes:  0(empty),   1,2,3,4
0080 
0081   // upgrade 2017:
0082   // depth: HB depth1,2; HE depth1,2,3,4,5,6,7; HO depth4; HF depth1,2,3,4
0083   // 8 depthes:  0(empty),   1,2,3,4,5,6,7
0084 
0085   // upgrade 2021:
0086   // depth: HB depth1,2,3,4; HE depth1,2,3,4,5,6,7; HO depth4; HF depth1,2,3,4
0087   // 10 depthes:  0(empty),   1,2,3,4,5,6,7,8,9
0088 
0089   //  Int_t ALLDEPTH = 5;
0090   //  Int_t ALLDEPTH = 8;
0091   Int_t ALLDEPTH = 10;
0092 
0093   int k_min[5] = {0, 1, 1, 4, 1};  // minimum depth for each subdet
0094   //     int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
0095   //       int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
0096   int k_max[5] = {0, 4, 7, 4, 4};  // maximum depth for each subdet
0097   ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
0098 
0099   const int nsub = 4;
0100   const int neta = 82;
0101   const int nphi = 72;
0102   int njeta = neta;
0103   int njphi = nphi;
0104   //const int ndepth = 7;
0105   int ndepth;
0106   /////////////   ///////////// //////////////////////////  /////////////  /////////////  /////////////  /////////////  /////////////  ////////////////////         Phi-symmetry for Calibration Group:
0107   /////////////  /////////////  //////////////////////////  /////////////  /////////////  /////////////  /////////////  ////////////////////         Phi-symmetry for Calibration Group:
0108   /////////////  /////////////  /////////////  /////////////  /////////////  /////////////  /////////////  ////////////////////         Phi-symmetry for Calibration Group:
0109 
0110   ////////////////////// Start   Recosignal  Start Recosignal  Start   Recosignal  Start   Recosignal  Start   Recosignal Start  Recosignal Start Recosignal Start Recosignal Start Recosignal Start Recosignal Start
0111   ////////////////////// Start   Recosignal  Start Recosignal  Start   Recosignal  Start   Recosignal  Start   Recosignal Start  Recosignal Start Recosignal Start Recosignal Start Recosignal Start Recosignal Start
0112   ////////////////////// Start   Recosignal  Start Recosignal  Start   Recosignal  Start   Recosignal  Start   Recosignal Start  Recosignal Start Recosignal Start Recosignal Start Recosignal Start Recosignal Start
0113   ////////////////////////////////////////////////////////////////////////////////////////////////////     Recosignal HB
0114   ////////////////////////////////////////////////////////////////////////////////////////////////////     Recosignal HB
0115   ////////////////////////////////////////////////////////////////////////////////////////////////////     Recosignal HB
0116   //  int k_max[5]={0,4,7,4,4}; // maximum depth for each subdet
0117   //ndepth = k_max[5];
0118   ndepth = 4;
0119   double arecosignalHB[ndepth][njeta][njphi];
0120   double recosignalvarianceHB[ndepth][njeta][njphi];
0121   //                                   RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR:   Recosignal HB  recSignalEnergy
0122   TH2F* recSignalEnergy1HB1 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy1_HB1");
0123   TH2F* recSignalEnergy0HB1 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HB1");
0124   TH2F* recSignalEnergyHB1 = (TH2F*)recSignalEnergy1HB1->Clone("recSignalEnergyHB1");
0125   recSignalEnergyHB1->Divide(recSignalEnergy1HB1, recSignalEnergy0HB1, 1, 1, "B");
0126   TH2F* recSignalEnergy1HB2 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy1_HB2");
0127   TH2F* recSignalEnergy0HB2 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HB2");
0128   TH2F* recSignalEnergyHB2 = (TH2F*)recSignalEnergy1HB2->Clone("recSignalEnergyHB2");
0129   recSignalEnergyHB2->Divide(recSignalEnergy1HB2, recSignalEnergy0HB2, 1, 1, "B");
0130   TH2F* recSignalEnergy1HB3 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy1_HB3");
0131   TH2F* recSignalEnergy0HB3 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HB3");
0132   TH2F* recSignalEnergyHB3 = (TH2F*)recSignalEnergy1HB3->Clone("recSignalEnergyHB3");
0133   recSignalEnergyHB3->Divide(recSignalEnergy1HB3, recSignalEnergy0HB3, 1, 1, "B");
0134   TH2F* recSignalEnergy1HB4 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy1_HB4");
0135   TH2F* recSignalEnergy0HB4 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HB4");
0136   TH2F* recSignalEnergyHB4 = (TH2F*)recSignalEnergy1HB4->Clone("recSignalEnergyHB4");
0137   recSignalEnergyHB4->Divide(recSignalEnergy1HB4, recSignalEnergy0HB4, 1, 1, "B");
0138   for (int jeta = 0; jeta < njeta; jeta++) {
0139     //====================================================================== PHI normalization & put R into massive arecosignalHB
0140     //preparation for PHI normalization:
0141     double sumrecosignalHB0 = 0;
0142     int nsumrecosignalHB0 = 0;
0143     double sumrecosignalHB1 = 0;
0144     int nsumrecosignalHB1 = 0;
0145     double sumrecosignalHB2 = 0;
0146     int nsumrecosignalHB2 = 0;
0147     double sumrecosignalHB3 = 0;
0148     int nsumrecosignalHB3 = 0;
0149     for (int jphi = 0; jphi < njphi; jphi++) {
0150       arecosignalHB[0][jeta][jphi] = recSignalEnergyHB1->GetBinContent(jeta + 1, jphi + 1);
0151       arecosignalHB[1][jeta][jphi] = recSignalEnergyHB2->GetBinContent(jeta + 1, jphi + 1);
0152       arecosignalHB[2][jeta][jphi] = recSignalEnergyHB3->GetBinContent(jeta + 1, jphi + 1);
0153       arecosignalHB[3][jeta][jphi] = recSignalEnergyHB4->GetBinContent(jeta + 1, jphi + 1);
0154       if (arecosignalHB[0][jeta][jphi] > 0.) {
0155         sumrecosignalHB0 += arecosignalHB[0][jeta][jphi];
0156         ++nsumrecosignalHB0;
0157       }
0158       if (arecosignalHB[1][jeta][jphi] > 0.) {
0159         sumrecosignalHB1 += arecosignalHB[1][jeta][jphi];
0160         ++nsumrecosignalHB1;
0161       }
0162       if (arecosignalHB[2][jeta][jphi] > 0.) {
0163         sumrecosignalHB2 += arecosignalHB[2][jeta][jphi];
0164         ++nsumrecosignalHB2;
0165       }
0166       if (arecosignalHB[3][jeta][jphi] > 0.) {
0167         sumrecosignalHB3 += arecosignalHB[3][jeta][jphi];
0168         ++nsumrecosignalHB3;
0169       }
0170     }  // phi
0171     // PHI normalization:
0172     for (int jphi = 0; jphi < njphi; jphi++) {
0173       if (arecosignalHB[0][jeta][jphi] > 0.)
0174         arecosignalHB[0][jeta][jphi] /= (sumrecosignalHB0 / nsumrecosignalHB0);
0175       if (arecosignalHB[1][jeta][jphi] > 0.)
0176         arecosignalHB[1][jeta][jphi] /= (sumrecosignalHB1 / nsumrecosignalHB1);
0177       if (arecosignalHB[2][jeta][jphi] > 0.)
0178         arecosignalHB[2][jeta][jphi] /= (sumrecosignalHB2 / nsumrecosignalHB2);
0179       if (arecosignalHB[3][jeta][jphi] > 0.)
0180         arecosignalHB[3][jeta][jphi] /= (sumrecosignalHB3 / nsumrecosignalHB3);
0181     }  // phi
0182   }    //eta
0183   //------------------------  2D-eta/phi-plot: R, averaged over depthfs
0184   //======================================================================
0185   //======================================================================
0186   //cout<<"      R2D-eta/phi-plot: R, averaged over depthfs *****" <<endl;
0187   c2x1->Clear();
0188   /////////////////
0189   c2x1->Divide(2, 1);
0190   c2x1->cd(1);
0191   TH2F* GefzRrecosignalHB42D = new TH2F("GefzRrecosignalHB42D", "", neta, -41., 41., nphi, 0., 72.);
0192   TH2F* GefzRrecosignalHB42D0 = new TH2F("GefzRrecosignalHB42D0", "", neta, -41., 41., nphi, 0., 72.);
0193   TH2F* GefzRrecosignalHB42DF = (TH2F*)GefzRrecosignalHB42D0->Clone("GefzRrecosignalHB42DF");
0194   for (int i = 0; i < ndepth; i++) {
0195     for (int jeta = 0; jeta < neta; jeta++) {
0196       for (int jphi = 0; jphi < nphi; jphi++) {
0197         double ccc1 = arecosignalHB[i][jeta][jphi];
0198         int k2plot = jeta - 41;
0199         int kkk = k2plot;  //if(k2plot >0 ) kkk=k2plot+1; //-41 +41 !=0
0200         if (ccc1 != 0.) {
0201           GefzRrecosignalHB42D->Fill(kkk, jphi, ccc1);
0202           GefzRrecosignalHB42D0->Fill(kkk, jphi, 1.);
0203         }
0204       }
0205     }
0206   }
0207   GefzRrecosignalHB42DF->Divide(GefzRrecosignalHB42D, GefzRrecosignalHB42D0, 1, 1, "B");  // average A
0208   gPad->SetGridy();
0209   gPad->SetGridx();  //      gPad->SetLogz();
0210   GefzRrecosignalHB42DF->SetXTitle("<R>_depth       #eta  \b");
0211   GefzRrecosignalHB42DF->SetYTitle("      #phi \b");
0212   GefzRrecosignalHB42DF->Draw("COLZ");
0213 
0214   c2x1->cd(2);
0215   TH1F* energyhitSignal_HB = (TH1F*)dir->FindObjectAny("h_energyhitSignal_HB");
0216   energyhitSignal_HB->SetMarkerStyle(20);
0217   energyhitSignal_HB->SetMarkerSize(0.4);
0218   energyhitSignal_HB->GetYaxis()->SetLabelSize(0.04);
0219   energyhitSignal_HB->SetXTitle("energyhitSignal_HB \b");
0220   energyhitSignal_HB->SetMarkerColor(2);
0221   energyhitSignal_HB->SetLineColor(0);
0222   gPad->SetGridy();
0223   gPad->SetGridx();
0224   energyhitSignal_HB->Draw("Error");
0225 
0226   /////////////////
0227   c2x1->Update();
0228   c2x1->Print("RrecosignalGeneralD2PhiSymmetryHB.png");
0229   c2x1->Clear();
0230   // clean-up
0231   if (GefzRrecosignalHB42D)
0232     delete GefzRrecosignalHB42D;
0233   if (GefzRrecosignalHB42D0)
0234     delete GefzRrecosignalHB42D0;
0235   if (GefzRrecosignalHB42DF)
0236     delete GefzRrecosignalHB42DF;
0237   //====================================================================== 1D plot: R vs phi , averaged over depthfs & eta
0238   //======================================================================
0239   //cout<<"      1D plot: R vs phi , averaged over depthfs & eta *****" <<endl;
0240   c1x1->Clear();
0241   /////////////////
0242   c1x1->Divide(1, 1);
0243   c1x1->cd(1);
0244   TH1F* GefzRrecosignalHB41D = new TH1F("GefzRrecosignalHB41D", "", nphi, 0., 72.);
0245   TH1F* GefzRrecosignalHB41D0 = new TH1F("GefzRrecosignalHB41D0", "", nphi, 0., 72.);
0246   TH1F* GefzRrecosignalHB41DF = (TH1F*)GefzRrecosignalHB41D0->Clone("GefzRrecosignalHB41DF");
0247   for (int jphi = 0; jphi < nphi; jphi++) {
0248     for (int jeta = 0; jeta < neta; jeta++) {
0249       for (int i = 0; i < ndepth; i++) {
0250         double ccc1 = arecosignalHB[i][jeta][jphi];
0251         if (ccc1 != 0.) {
0252           GefzRrecosignalHB41D->Fill(jphi, ccc1);
0253           GefzRrecosignalHB41D0->Fill(jphi, 1.);
0254         }
0255       }
0256     }
0257   }
0258   GefzRrecosignalHB41DF->Divide(
0259       GefzRrecosignalHB41D, GefzRrecosignalHB41D0, 1, 1, "B");  // R averaged over depthfs & eta
0260   GefzRrecosignalHB41D0->Sumw2();
0261   //    for (int jphi=1;jphi<73;jphi++) {GefzRrecosignalHB41DF->SetBinError(jphi,0.01);}
0262   gPad->SetGridy();
0263   gPad->SetGridx();  //      gPad->SetLogz();
0264   GefzRrecosignalHB41DF->SetMarkerStyle(20);
0265   GefzRrecosignalHB41DF->SetMarkerSize(1.4);
0266   GefzRrecosignalHB41DF->GetZaxis()->SetLabelSize(0.08);
0267   GefzRrecosignalHB41DF->SetXTitle("#phi  \b");
0268   GefzRrecosignalHB41DF->SetYTitle("  <R> \b");
0269   GefzRrecosignalHB41DF->SetZTitle("<R>_PHI  - AllDepthfs \b");
0270   GefzRrecosignalHB41DF->SetMarkerColor(4);
0271   GefzRrecosignalHB41DF->SetLineColor(
0272       4);  //  GefzRrecosignalHB41DF->SetMinimum(0.8);     //      GefzRrecosignalHB41DF->SetMaximum(1.000);
0273   GefzRrecosignalHB41DF->Draw("Error");
0274   /////////////////
0275   c1x1->Update();
0276   c1x1->Print("RrecosignalGeneralD1PhiSymmetryHB.png");
0277   c1x1->Clear();
0278   // clean-up
0279   if (GefzRrecosignalHB41D)
0280     delete GefzRrecosignalHB41D;
0281   if (GefzRrecosignalHB41D0)
0282     delete GefzRrecosignalHB41D0;
0283   if (GefzRrecosignalHB41DF)
0284     delete GefzRrecosignalHB41DF;
0285   //========================================================================================== 4
0286   //======================================================================
0287   //======================================================================1D plot: R vs phi , different eta,  depth=1
0288   //cout<<"      1D plot: R vs phi , different eta,  depth=1 *****" <<endl;
0289   c3x5->Clear();
0290   /////////////////
0291   c3x5->Divide(4, 4);
0292   c3x5->cd(1);
0293   int kcountHBpositivedirectionRecosignal1 = 1;
0294   TH1F* h2CeffHBpositivedirectionRecosignal1 = new TH1F("h2CeffHBpositivedirectionRecosignal1", "", nphi, 0., 72.);
0295   for (int jeta = 0; jeta < njeta; jeta++) {
0296     // positivedirectionRecosignal:
0297     if (jeta - 41 >= 0) {
0298       //         for (int i=0;i<ndepth;i++) {
0299       // depth=1
0300       for (int i = 0; i < 1; i++) {
0301         TH1F* HBpositivedirectionRecosignal1 = (TH1F*)h2CeffHBpositivedirectionRecosignal1->Clone("twod1");
0302         float ccctest = 0;  // to avoid empty massive elements
0303         for (int jphi = 0; jphi < nphi; jphi++) {
0304           double ccc1 = arecosignalHB[i][jeta][jphi];
0305           if (ccc1 != 0.) {
0306             HBpositivedirectionRecosignal1->Fill(jphi, ccc1);
0307             ccctest = 1.;  //HBpositivedirectionRecosignal1->SetBinError(i,0.01);
0308           }
0309         }  // for jphi
0310         if (ccctest > 0.) {
0311           //      cout<<"444        kcountHBpositivedirectionRecosignal1   =     "<<kcountHBpositivedirectionRecosignal1  <<"   jeta-41=     "<< jeta-41 <<endl;
0312           c3x5->cd(kcountHBpositivedirectionRecosignal1);
0313           HBpositivedirectionRecosignal1->SetMarkerStyle(20);
0314           HBpositivedirectionRecosignal1->SetMarkerSize(0.4);
0315           HBpositivedirectionRecosignal1->GetYaxis()->SetLabelSize(0.04);
0316           HBpositivedirectionRecosignal1->SetXTitle("HBpositivedirectionRecosignal1 \b");
0317           HBpositivedirectionRecosignal1->SetMarkerColor(2);
0318           HBpositivedirectionRecosignal1->SetLineColor(0);
0319           gPad->SetGridy();
0320           gPad->SetGridx();
0321           //       gPad->SetLogy();
0322           if (kcountHBpositivedirectionRecosignal1 == 1)
0323             HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta =  0; depth = 1 \b");
0324           if (kcountHBpositivedirectionRecosignal1 == 2)
0325             HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta =  1; depth = 1 \b");
0326           if (kcountHBpositivedirectionRecosignal1 == 3)
0327             HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta =  2; depth = 1 \b");
0328           if (kcountHBpositivedirectionRecosignal1 == 4)
0329             HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta =  3; depth = 1 \b");
0330           if (kcountHBpositivedirectionRecosignal1 == 5)
0331             HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta =  4; depth = 1 \b");
0332           if (kcountHBpositivedirectionRecosignal1 == 6)
0333             HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta =  5; depth = 1 \b");
0334           if (kcountHBpositivedirectionRecosignal1 == 7)
0335             HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta =  6; depth = 1 \b");
0336           if (kcountHBpositivedirectionRecosignal1 == 8)
0337             HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta =  7; depth = 1 \b");
0338           if (kcountHBpositivedirectionRecosignal1 == 9)
0339             HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta =  8; depth = 1 \b");
0340           if (kcountHBpositivedirectionRecosignal1 == 10)
0341             HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta =  9; depth = 1 \b");
0342           if (kcountHBpositivedirectionRecosignal1 == 11)
0343             HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 10; depth = 1 \b");
0344           if (kcountHBpositivedirectionRecosignal1 == 12)
0345             HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 11; depth = 1 \b");
0346           if (kcountHBpositivedirectionRecosignal1 == 13)
0347             HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 12; depth = 1 \b");
0348           if (kcountHBpositivedirectionRecosignal1 == 14)
0349             HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 13; depth = 1 \b");
0350           if (kcountHBpositivedirectionRecosignal1 == 15)
0351             HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 14; depth = 1 \b");
0352           if (kcountHBpositivedirectionRecosignal1 == 16)
0353             HBpositivedirectionRecosignal1->SetXTitle("R for HB+ jeta = 15; depth = 1 \b");
0354           HBpositivedirectionRecosignal1->Draw("Error");
0355           kcountHBpositivedirectionRecosignal1++;
0356           if (kcountHBpositivedirectionRecosignal1 > 16)
0357             break;  //
0358         }           //ccctest>0
0359 
0360       }  // for i
0361     }    //if(jeta-41 >= 0)
0362   }      //for jeta
0363   /////////////////
0364   c3x5->Update();
0365   c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth1HB.png");
0366   c3x5->Clear();
0367   // clean-up
0368   if (h2CeffHBpositivedirectionRecosignal1)
0369     delete h2CeffHBpositivedirectionRecosignal1;
0370 
0371   //========================================================================================== 5
0372   //======================================================================
0373   //======================================================================1D plot: R vs phi , different eta,  depth=2
0374   //  cout<<"      1D plot: R vs phi , different eta,  depth=2 *****" <<endl;
0375   c3x5->Clear();
0376   /////////////////
0377   c3x5->Divide(4, 4);
0378   c3x5->cd(1);
0379   int kcountHBpositivedirectionRecosignal2 = 1;
0380   TH1F* h2CeffHBpositivedirectionRecosignal2 = new TH1F("h2CeffHBpositivedirectionRecosignal2", "", nphi, 0., 72.);
0381   for (int jeta = 0; jeta < njeta; jeta++) {
0382     // positivedirectionRecosignal:
0383     if (jeta - 41 >= 0) {
0384       //         for (int i=0;i<ndepth;i++) {
0385       // depth=2
0386       for (int i = 1; i < 2; i++) {
0387         TH1F* HBpositivedirectionRecosignal2 = (TH1F*)h2CeffHBpositivedirectionRecosignal2->Clone("twod1");
0388         float ccctest = 0;  // to avoid empty massive elements
0389         for (int jphi = 0; jphi < nphi; jphi++) {
0390           double ccc1 = arecosignalHB[i][jeta][jphi];
0391           if (ccc1 != 0.) {
0392             HBpositivedirectionRecosignal2->Fill(jphi, ccc1);
0393             ccctest = 1.;  //HBpositivedirectionRecosignal2->SetBinError(i,0.01);
0394           }
0395         }  // for jphi
0396         if (ccctest > 0.) {
0397           //cout<<"555        kcountHBpositivedirectionRecosignal2   =     "<<kcountHBpositivedirectionRecosignal2  <<"   jeta-41=     "<< jeta-41 <<endl;
0398           c3x5->cd(kcountHBpositivedirectionRecosignal2);
0399           HBpositivedirectionRecosignal2->SetMarkerStyle(20);
0400           HBpositivedirectionRecosignal2->SetMarkerSize(0.4);
0401           HBpositivedirectionRecosignal2->GetYaxis()->SetLabelSize(0.04);
0402           HBpositivedirectionRecosignal2->SetXTitle("HBpositivedirectionRecosignal2 \b");
0403           HBpositivedirectionRecosignal2->SetMarkerColor(2);
0404           HBpositivedirectionRecosignal2->SetLineColor(0);
0405           gPad->SetGridy();
0406           gPad->SetGridx();
0407           //       gPad->SetLogy();
0408           if (kcountHBpositivedirectionRecosignal2 == 1)
0409             HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta =  0; depth = 2 \b");
0410           if (kcountHBpositivedirectionRecosignal2 == 2)
0411             HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta =  1; depth = 2 \b");
0412           if (kcountHBpositivedirectionRecosignal2 == 3)
0413             HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta =  2; depth = 2 \b");
0414           if (kcountHBpositivedirectionRecosignal2 == 4)
0415             HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta =  3; depth = 2 \b");
0416           if (kcountHBpositivedirectionRecosignal2 == 5)
0417             HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta =  4; depth = 2 \b");
0418           if (kcountHBpositivedirectionRecosignal2 == 6)
0419             HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta =  5; depth = 2 \b");
0420           if (kcountHBpositivedirectionRecosignal2 == 7)
0421             HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta =  6; depth = 2 \b");
0422           if (kcountHBpositivedirectionRecosignal2 == 8)
0423             HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta =  7; depth = 2 \b");
0424           if (kcountHBpositivedirectionRecosignal2 == 9)
0425             HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta =  8; depth = 2 \b");
0426           if (kcountHBpositivedirectionRecosignal2 == 10)
0427             HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta =  9; depth = 2 \b");
0428           if (kcountHBpositivedirectionRecosignal2 == 11)
0429             HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 10; depth = 2 \b");
0430           if (kcountHBpositivedirectionRecosignal2 == 12)
0431             HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 11; depth = 2 \b");
0432           if (kcountHBpositivedirectionRecosignal2 == 13)
0433             HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 12; depth = 2 \b");
0434           if (kcountHBpositivedirectionRecosignal2 == 14)
0435             HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 13; depth = 2 \b");
0436           if (kcountHBpositivedirectionRecosignal2 == 15)
0437             HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 14; depth = 2 \b");
0438           if (kcountHBpositivedirectionRecosignal2 == 16)
0439             HBpositivedirectionRecosignal2->SetXTitle("R for HB+ jeta = 15; depth = 2 \b");
0440           HBpositivedirectionRecosignal2->Draw("Error");
0441           kcountHBpositivedirectionRecosignal2++;
0442           if (kcountHBpositivedirectionRecosignal2 > 16)
0443             break;  // 4x6 = 24
0444         }           //ccctest>0
0445 
0446       }  // for i
0447     }    //if(jeta-41 >= 0)
0448   }      //for jeta
0449   /////////////////
0450   c3x5->Update();
0451   c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth2HB.png");
0452   c3x5->Clear();
0453   // clean-up
0454   if (h2CeffHBpositivedirectionRecosignal2)
0455     delete h2CeffHBpositivedirectionRecosignal2;
0456   //========================================================================================== 6
0457   //======================================================================
0458   //======================================================================1D plot: R vs phi , different eta,  depth=3
0459   //cout<<"      1D plot: R vs phi , different eta,  depth=3 *****" <<endl;
0460   c3x5->Clear();
0461   /////////////////
0462   c3x5->Divide(4, 4);
0463   c3x5->cd(1);
0464   int kcountHBpositivedirectionRecosignal3 = 1;
0465   TH1F* h2CeffHBpositivedirectionRecosignal3 = new TH1F("h2CeffHBpositivedirectionRecosignal3", "", nphi, 0., 72.);
0466   for (int jeta = 0; jeta < njeta; jeta++) {
0467     // positivedirectionRecosignal:
0468     if (jeta - 41 >= 0) {
0469       //         for (int i=0;i<ndepth;i++) {
0470       // depth=3
0471       for (int i = 2; i < 3; i++) {
0472         TH1F* HBpositivedirectionRecosignal3 = (TH1F*)h2CeffHBpositivedirectionRecosignal3->Clone("twod1");
0473         float ccctest = 0;  // to avoid empty massive elements
0474         for (int jphi = 0; jphi < nphi; jphi++) {
0475           double ccc1 = arecosignalHB[i][jeta][jphi];
0476           if (ccc1 != 0.) {
0477             HBpositivedirectionRecosignal3->Fill(jphi, ccc1);
0478             ccctest = 1.;  //HBpositivedirectionRecosignal3->SetBinError(i,0.01);
0479           }
0480         }  // for jphi
0481         if (ccctest > 0.) {
0482           //cout<<"666        kcountHBpositivedirectionRecosignal3   =     "<<kcountHBpositivedirectionRecosignal3  <<"   jeta-41=     "<< jeta-41 <<endl;
0483           c3x5->cd(kcountHBpositivedirectionRecosignal3);
0484           HBpositivedirectionRecosignal3->SetMarkerStyle(20);
0485           HBpositivedirectionRecosignal3->SetMarkerSize(0.4);
0486           HBpositivedirectionRecosignal3->GetYaxis()->SetLabelSize(0.04);
0487           HBpositivedirectionRecosignal3->SetXTitle("HBpositivedirectionRecosignal3 \b");
0488           HBpositivedirectionRecosignal3->SetMarkerColor(2);
0489           HBpositivedirectionRecosignal3->SetLineColor(0);
0490           gPad->SetGridy();
0491           gPad->SetGridx();
0492           //       gPad->SetLogy();
0493           if (kcountHBpositivedirectionRecosignal3 == 1)
0494             HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta =  0; depth = 3 \b");
0495           if (kcountHBpositivedirectionRecosignal3 == 2)
0496             HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta =  1; depth = 3 \b");
0497           if (kcountHBpositivedirectionRecosignal3 == 3)
0498             HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta =  2; depth = 3 \b");
0499           if (kcountHBpositivedirectionRecosignal3 == 4)
0500             HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta =  3; depth = 3 \b");
0501           if (kcountHBpositivedirectionRecosignal3 == 5)
0502             HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta =  4; depth = 3 \b");
0503           if (kcountHBpositivedirectionRecosignal3 == 6)
0504             HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta =  5; depth = 3 \b");
0505           if (kcountHBpositivedirectionRecosignal3 == 7)
0506             HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta =  6; depth = 3 \b");
0507           if (kcountHBpositivedirectionRecosignal3 == 8)
0508             HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta =  7; depth = 3 \b");
0509           if (kcountHBpositivedirectionRecosignal3 == 9)
0510             HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta =  8; depth = 3 \b");
0511           if (kcountHBpositivedirectionRecosignal3 == 10)
0512             HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta =  9; depth = 3 \b");
0513           if (kcountHBpositivedirectionRecosignal3 == 11)
0514             HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta =  0; depth = 3 \b");
0515           if (kcountHBpositivedirectionRecosignal3 == 12)
0516             HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 11; depth = 3 \b");
0517           if (kcountHBpositivedirectionRecosignal3 == 13)
0518             HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 12; depth = 3 \b");
0519           if (kcountHBpositivedirectionRecosignal3 == 14)
0520             HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 13; depth = 3 \b");
0521           if (kcountHBpositivedirectionRecosignal3 == 15)
0522             HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 14; depth = 3 \b");
0523           if (kcountHBpositivedirectionRecosignal3 == 16)
0524             HBpositivedirectionRecosignal3->SetXTitle("R for HB+ jeta = 15; depth = 3 \b");
0525           HBpositivedirectionRecosignal3->Draw("Error");
0526           kcountHBpositivedirectionRecosignal3++;
0527           if (kcountHBpositivedirectionRecosignal3 > 16)
0528             break;  // 4x6 = 24
0529         }           //ccctest>0
0530 
0531       }  // for i
0532     }    //if(jeta-41 >= 0)
0533   }      //for jeta
0534   /////////////////
0535   c3x5->Update();
0536   c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth3HB.png");
0537   c3x5->Clear();
0538   // clean-up
0539   if (h2CeffHBpositivedirectionRecosignal3)
0540     delete h2CeffHBpositivedirectionRecosignal3;
0541   //========================================================================================== 7
0542   //======================================================================
0543   //======================================================================1D plot: R vs phi , different eta,  depth=4
0544   //cout<<"      1D plot: R vs phi , different eta,  depth=4 *****" <<endl;
0545   c3x5->Clear();
0546   /////////////////
0547   c3x5->Divide(4, 4);
0548   c3x5->cd(1);
0549   int kcountHBpositivedirectionRecosignal4 = 1;
0550   TH1F* h2CeffHBpositivedirectionRecosignal4 = new TH1F("h2CeffHBpositivedirectionRecosignal4", "", nphi, 0., 72.);
0551 
0552   for (int jeta = 0; jeta < njeta; jeta++) {
0553     // positivedirectionRecosignal:
0554     if (jeta - 41 >= 0) {
0555       //         for (int i=0;i<ndepth;i++) {
0556       // depth=4
0557       for (int i = 3; i < 4; i++) {
0558         TH1F* HBpositivedirectionRecosignal4 = (TH1F*)h2CeffHBpositivedirectionRecosignal4->Clone("twod1");
0559 
0560         float ccctest = 0;  // to avoid empty massive elements
0561         for (int jphi = 0; jphi < nphi; jphi++) {
0562           double ccc1 = arecosignalHB[i][jeta][jphi];
0563           if (ccc1 != 0.) {
0564             HBpositivedirectionRecosignal4->Fill(jphi, ccc1);
0565             ccctest = 1.;  //HBpositivedirectionRecosignal4->SetBinError(i,0.01);
0566           }
0567         }  // for jphi
0568         if (ccctest > 0.) {
0569           //cout<<"777        kcountHBpositivedirectionRecosignal4   =     "<<kcountHBpositivedirectionRecosignal4  <<"   jeta-41=     "<< jeta-41 <<endl;
0570           c3x5->cd(kcountHBpositivedirectionRecosignal4);
0571           HBpositivedirectionRecosignal4->SetMarkerStyle(20);
0572           HBpositivedirectionRecosignal4->SetMarkerSize(0.4);
0573           HBpositivedirectionRecosignal4->GetYaxis()->SetLabelSize(0.04);
0574           HBpositivedirectionRecosignal4->SetXTitle("HBpositivedirectionRecosignal4 \b");
0575           HBpositivedirectionRecosignal4->SetMarkerColor(2);
0576           HBpositivedirectionRecosignal4->SetLineColor(0);
0577           gPad->SetGridy();
0578           gPad->SetGridx();
0579           //       gPad->SetLogy();
0580           if (kcountHBpositivedirectionRecosignal4 == 1)
0581             HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta =  0; depth = 4 \b");
0582           if (kcountHBpositivedirectionRecosignal4 == 2)
0583             HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta =  1; depth = 4 \b");
0584           if (kcountHBpositivedirectionRecosignal4 == 3)
0585             HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta =  2; depth = 4 \b");
0586           if (kcountHBpositivedirectionRecosignal4 == 4)
0587             HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta =  3; depth = 4 \b");
0588           if (kcountHBpositivedirectionRecosignal4 == 5)
0589             HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta =  4; depth = 4 \b");
0590           if (kcountHBpositivedirectionRecosignal4 == 6)
0591             HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta =  5; depth = 4 \b");
0592           if (kcountHBpositivedirectionRecosignal4 == 7)
0593             HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta =  6; depth = 4 \b");
0594           if (kcountHBpositivedirectionRecosignal4 == 8)
0595             HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta =  7; depth = 4 \b");
0596           if (kcountHBpositivedirectionRecosignal4 == 9)
0597             HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta =  8; depth = 4 \b");
0598           if (kcountHBpositivedirectionRecosignal4 == 10)
0599             HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta =  9; depth = 4 \b");
0600           if (kcountHBpositivedirectionRecosignal4 == 11)
0601             HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 10; depth = 4 \b");
0602           if (kcountHBpositivedirectionRecosignal4 == 12)
0603             HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 11; depth = 4 \b");
0604           if (kcountHBpositivedirectionRecosignal4 == 13)
0605             HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 12; depth = 4 \b");
0606           if (kcountHBpositivedirectionRecosignal4 == 14)
0607             HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 13; depth = 4 \b");
0608           if (kcountHBpositivedirectionRecosignal4 == 15)
0609             HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 14; depth = 4 \b");
0610           if (kcountHBpositivedirectionRecosignal4 == 16)
0611             HBpositivedirectionRecosignal4->SetXTitle("R for HB+ jeta = 15; depth = 4 \b");
0612           HBpositivedirectionRecosignal4->Draw("Error");
0613           kcountHBpositivedirectionRecosignal4++;
0614           if (kcountHBpositivedirectionRecosignal4 > 16)
0615             break;  // 4x6 = 24
0616         }           //ccctest>0
0617 
0618       }  // for i
0619     }    //if(jeta-41 >= 0)
0620   }      //for jeta
0621   /////////////////
0622   c3x5->Update();
0623   c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth4HB.png");
0624   c3x5->Clear();
0625   // clean-up
0626   if (h2CeffHBpositivedirectionRecosignal4)
0627     delete h2CeffHBpositivedirectionRecosignal4;
0628 
0629   //========================================================================================== 1114
0630   //======================================================================
0631   //======================================================================1D plot: R vs phi , different eta,  depth=1
0632   //cout<<"      1D plot: R vs phi , different eta,  depth=1 *****" <<endl;
0633   c3x5->Clear();
0634   /////////////////
0635   c3x5->Divide(4, 4);
0636   c3x5->cd(1);
0637   int kcountHBnegativedirectionRecosignal1 = 1;
0638   TH1F* h2CeffHBnegativedirectionRecosignal1 = new TH1F("h2CeffHBnegativedirectionRecosignal1", "", nphi, 0., 72.);
0639   for (int jeta = 0; jeta < njeta; jeta++) {
0640     // negativedirectionRecosignal:
0641     if (jeta - 41 < 0) {
0642       //         for (int i=0;i<ndepth;i++) {
0643       // depth=1
0644       for (int i = 0; i < 1; i++) {
0645         TH1F* HBnegativedirectionRecosignal1 = (TH1F*)h2CeffHBnegativedirectionRecosignal1->Clone("twod1");
0646         float ccctest = 0;  // to avoid empty massive elements
0647         for (int jphi = 0; jphi < nphi; jphi++) {
0648           double ccc1 = arecosignalHB[i][jeta][jphi];
0649           if (ccc1 != 0.) {
0650             HBnegativedirectionRecosignal1->Fill(jphi, ccc1);
0651             ccctest = 1.;  //HBnegativedirectionRecosignal1->SetBinError(i,0.01);
0652           }
0653         }  // for jphi
0654         if (ccctest > 0.) {
0655           //      cout<<"444        kcountHBnegativedirectionRecosignal1   =     "<<kcountHBnegativedirectionRecosignal1  <<"   jeta-41=     "<< jeta-41 <<endl;
0656           c3x5->cd(kcountHBnegativedirectionRecosignal1);
0657           HBnegativedirectionRecosignal1->SetMarkerStyle(20);
0658           HBnegativedirectionRecosignal1->SetMarkerSize(0.4);
0659           HBnegativedirectionRecosignal1->GetYaxis()->SetLabelSize(0.04);
0660           HBnegativedirectionRecosignal1->SetXTitle("HBnegativedirectionRecosignal1 \b");
0661           HBnegativedirectionRecosignal1->SetMarkerColor(2);
0662           HBnegativedirectionRecosignal1->SetLineColor(0);
0663           gPad->SetGridy();
0664           gPad->SetGridx();
0665           //       gPad->SetLogy();
0666           if (kcountHBnegativedirectionRecosignal1 == 1)
0667             HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -16; depth = 1 \b");
0668           if (kcountHBnegativedirectionRecosignal1 == 2)
0669             HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -15; depth = 1 \b");
0670           if (kcountHBnegativedirectionRecosignal1 == 3)
0671             HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -14; depth = 1 \b");
0672           if (kcountHBnegativedirectionRecosignal1 == 4)
0673             HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -13; depth = 1 \b");
0674           if (kcountHBnegativedirectionRecosignal1 == 5)
0675             HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -12; depth = 1 \b");
0676           if (kcountHBnegativedirectionRecosignal1 == 6)
0677             HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -11; depth = 1 \b");
0678           if (kcountHBnegativedirectionRecosignal1 == 7)
0679             HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta = -10; depth = 1 \b");
0680           if (kcountHBnegativedirectionRecosignal1 == 8)
0681             HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta =  -9; depth = 1 \b");
0682           if (kcountHBnegativedirectionRecosignal1 == 9)
0683             HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta =  -8; depth = 1 \b");
0684           if (kcountHBnegativedirectionRecosignal1 == 10)
0685             HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta =  -7; depth = 1 \b");
0686           if (kcountHBnegativedirectionRecosignal1 == 11)
0687             HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta =  -6; depth = 1 \b");
0688           if (kcountHBnegativedirectionRecosignal1 == 12)
0689             HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta =  -5; depth = 1 \b");
0690           if (kcountHBnegativedirectionRecosignal1 == 13)
0691             HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta =  -4; depth = 1 \b");
0692           if (kcountHBnegativedirectionRecosignal1 == 14)
0693             HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta =  -3; depth = 1 \b");
0694           if (kcountHBnegativedirectionRecosignal1 == 15)
0695             HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta =  -2; depth = 1 \b");
0696           if (kcountHBnegativedirectionRecosignal1 == 16)
0697             HBnegativedirectionRecosignal1->SetXTitle("R for HB- jeta =  -1; depth = 1 \b");
0698           HBnegativedirectionRecosignal1->Draw("Error");
0699           kcountHBnegativedirectionRecosignal1++;
0700           if (kcountHBnegativedirectionRecosignal1 > 16)
0701             break;  //
0702         }           //ccctest>0
0703 
0704       }  // for i
0705     }    //if(jeta-41 < 0 )
0706   }      //for jeta
0707   /////////////////
0708   c3x5->Update();
0709   c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth1HB.png");
0710   c3x5->Clear();
0711   // clean-up
0712   if (h2CeffHBnegativedirectionRecosignal1)
0713     delete h2CeffHBnegativedirectionRecosignal1;
0714 
0715   //========================================================================================== 1115
0716   //======================================================================
0717   //======================================================================1D plot: R vs phi , different eta,  depth=2
0718   //  cout<<"      1D plot: R vs phi , different eta,  depth=2 *****" <<endl;
0719   c3x5->Clear();
0720   /////////////////
0721   c3x5->Divide(4, 4);
0722   c3x5->cd(1);
0723   int kcountHBnegativedirectionRecosignal2 = 1;
0724   TH1F* h2CeffHBnegativedirectionRecosignal2 = new TH1F("h2CeffHBnegativedirectionRecosignal2", "", nphi, 0., 72.);
0725   for (int jeta = 0; jeta < njeta; jeta++) {
0726     // negativedirectionRecosignal:
0727     if (jeta - 41 < 0) {
0728       //         for (int i=0;i<ndepth;i++) {
0729       // depth=2
0730       for (int i = 1; i < 2; i++) {
0731         TH1F* HBnegativedirectionRecosignal2 = (TH1F*)h2CeffHBnegativedirectionRecosignal2->Clone("twod1");
0732         float ccctest = 0;  // to avoid empty massive elements
0733         for (int jphi = 0; jphi < nphi; jphi++) {
0734           double ccc1 = arecosignalHB[i][jeta][jphi];
0735           if (ccc1 != 0.) {
0736             HBnegativedirectionRecosignal2->Fill(jphi, ccc1);
0737             ccctest = 1.;  //HBnegativedirectionRecosignal2->SetBinError(i,0.01);
0738           }
0739         }  // for jphi
0740         if (ccctest > 0.) {
0741           //cout<<"555        kcountHBnegativedirectionRecosignal2   =     "<<kcountHBnegativedirectionRecosignal2  <<"   jeta-41=     "<< jeta-41 <<endl;
0742           c3x5->cd(kcountHBnegativedirectionRecosignal2);
0743           HBnegativedirectionRecosignal2->SetMarkerStyle(20);
0744           HBnegativedirectionRecosignal2->SetMarkerSize(0.4);
0745           HBnegativedirectionRecosignal2->GetYaxis()->SetLabelSize(0.04);
0746           HBnegativedirectionRecosignal2->SetXTitle("HBnegativedirectionRecosignal2 \b");
0747           HBnegativedirectionRecosignal2->SetMarkerColor(2);
0748           HBnegativedirectionRecosignal2->SetLineColor(0);
0749           gPad->SetGridy();
0750           gPad->SetGridx();
0751           //       gPad->SetLogy();
0752           if (kcountHBnegativedirectionRecosignal2 == 1)
0753             HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -16; depth = 2 \b");
0754           if (kcountHBnegativedirectionRecosignal2 == 2)
0755             HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -15; depth = 2 \b");
0756           if (kcountHBnegativedirectionRecosignal2 == 3)
0757             HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -14; depth = 2 \b");
0758           if (kcountHBnegativedirectionRecosignal2 == 4)
0759             HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -13; depth = 2 \b");
0760           if (kcountHBnegativedirectionRecosignal2 == 5)
0761             HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -12; depth = 2 \b");
0762           if (kcountHBnegativedirectionRecosignal2 == 6)
0763             HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -11; depth = 2 \b");
0764           if (kcountHBnegativedirectionRecosignal2 == 7)
0765             HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta = -10; depth = 2 \b");
0766           if (kcountHBnegativedirectionRecosignal2 == 8)
0767             HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta =  -9; depth = 2 \b");
0768           if (kcountHBnegativedirectionRecosignal2 == 9)
0769             HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta =  -8; depth = 2 \b");
0770           if (kcountHBnegativedirectionRecosignal2 == 10)
0771             HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta =  -7; depth = 2 \b");
0772           if (kcountHBnegativedirectionRecosignal2 == 11)
0773             HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta =  -6; depth = 2 \b");
0774           if (kcountHBnegativedirectionRecosignal2 == 12)
0775             HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta =  -5; depth = 2 \b");
0776           if (kcountHBnegativedirectionRecosignal2 == 13)
0777             HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta =  -4; depth = 2 \b");
0778           if (kcountHBnegativedirectionRecosignal2 == 14)
0779             HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta =  -3; depth = 2 \b");
0780           if (kcountHBnegativedirectionRecosignal2 == 15)
0781             HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta =  -2; depth = 2 \b");
0782           if (kcountHBnegativedirectionRecosignal2 == 16)
0783             HBnegativedirectionRecosignal2->SetXTitle("R for HB- jeta =  -1; depth = 2 \b");
0784           HBnegativedirectionRecosignal2->Draw("Error");
0785           kcountHBnegativedirectionRecosignal2++;
0786           if (kcountHBnegativedirectionRecosignal2 > 16)
0787             break;  // 4x6 = 24
0788         }           //ccctest>0
0789 
0790       }  // for i
0791     }    //if(jeta-41 < 0 )
0792   }      //for jeta
0793   /////////////////
0794   c3x5->Update();
0795   c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth2HB.png");
0796   c3x5->Clear();
0797   // clean-up
0798   if (h2CeffHBnegativedirectionRecosignal2)
0799     delete h2CeffHBnegativedirectionRecosignal2;
0800   //========================================================================================== 1116
0801   //======================================================================
0802   //======================================================================1D plot: R vs phi , different eta,  depth=3
0803   //cout<<"      1D plot: R vs phi , different eta,  depth=3 *****" <<endl;
0804   c3x5->Clear();
0805   /////////////////
0806   c3x5->Divide(4, 4);
0807   c3x5->cd(1);
0808   int kcountHBnegativedirectionRecosignal3 = 1;
0809   TH1F* h2CeffHBnegativedirectionRecosignal3 = new TH1F("h2CeffHBnegativedirectionRecosignal3", "", nphi, 0., 72.);
0810   for (int jeta = 0; jeta < njeta; jeta++) {
0811     // negativedirectionRecosignal:
0812     if (jeta - 41 < 0) {
0813       //         for (int i=0;i<ndepth;i++) {
0814       // depth=3
0815       for (int i = 2; i < 3; i++) {
0816         TH1F* HBnegativedirectionRecosignal3 = (TH1F*)h2CeffHBnegativedirectionRecosignal3->Clone("twod1");
0817         float ccctest = 0;  // to avoid empty massive elements
0818         for (int jphi = 0; jphi < nphi; jphi++) {
0819           double ccc1 = arecosignalHB[i][jeta][jphi];
0820           if (ccc1 != 0.) {
0821             HBnegativedirectionRecosignal3->Fill(jphi, ccc1);
0822             ccctest = 1.;  //HBnegativedirectionRecosignal3->SetBinError(i,0.01);
0823           }
0824         }  // for jphi
0825         if (ccctest > 0.) {
0826           //cout<<"666        kcountHBnegativedirectionRecosignal3   =     "<<kcountHBnegativedirectionRecosignal3  <<"   jeta-41=     "<< jeta-41 <<endl;
0827           c3x5->cd(kcountHBnegativedirectionRecosignal3);
0828           HBnegativedirectionRecosignal3->SetMarkerStyle(20);
0829           HBnegativedirectionRecosignal3->SetMarkerSize(0.4);
0830           HBnegativedirectionRecosignal3->GetYaxis()->SetLabelSize(0.04);
0831           HBnegativedirectionRecosignal3->SetXTitle("HBnegativedirectionRecosignal3 \b");
0832           HBnegativedirectionRecosignal3->SetMarkerColor(2);
0833           HBnegativedirectionRecosignal3->SetLineColor(0);
0834           gPad->SetGridy();
0835           gPad->SetGridx();
0836           //       gPad->SetLogy();
0837           if (kcountHBnegativedirectionRecosignal3 == 1)
0838             HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -16; depth = 3 \b");
0839           if (kcountHBnegativedirectionRecosignal3 == 2)
0840             HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -15; depth = 3 \b");
0841           if (kcountHBnegativedirectionRecosignal3 == 3)
0842             HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -14; depth = 3 \b");
0843           if (kcountHBnegativedirectionRecosignal3 == 4)
0844             HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -13; depth = 3 \b");
0845           if (kcountHBnegativedirectionRecosignal3 == 5)
0846             HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -12; depth = 3 \b");
0847           if (kcountHBnegativedirectionRecosignal3 == 6)
0848             HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -11; depth = 3 \b");
0849           if (kcountHBnegativedirectionRecosignal3 == 7)
0850             HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta = -10; depth = 3 \b");
0851           if (kcountHBnegativedirectionRecosignal3 == 8)
0852             HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta =  -9; depth = 3 \b");
0853           if (kcountHBnegativedirectionRecosignal3 == 9)
0854             HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta =  -8; depth = 3 \b");
0855           if (kcountHBnegativedirectionRecosignal3 == 10)
0856             HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta =  -7; depth = 3 \b");
0857           if (kcountHBnegativedirectionRecosignal3 == 11)
0858             HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta =  -6; depth = 3 \b");
0859           if (kcountHBnegativedirectionRecosignal3 == 12)
0860             HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta =  -5; depth = 3 \b");
0861           if (kcountHBnegativedirectionRecosignal3 == 13)
0862             HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta =  -4; depth = 3 \b");
0863           if (kcountHBnegativedirectionRecosignal3 == 14)
0864             HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta =  -3; depth = 3 \b");
0865           if (kcountHBnegativedirectionRecosignal3 == 15)
0866             HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta =  -2; depth = 3 \b");
0867           if (kcountHBnegativedirectionRecosignal3 == 16)
0868             HBnegativedirectionRecosignal3->SetXTitle("R for HB- jeta =  -1; depth = 3 \b");
0869 
0870           HBnegativedirectionRecosignal3->Draw("Error");
0871           kcountHBnegativedirectionRecosignal3++;
0872           if (kcountHBnegativedirectionRecosignal3 > 16)
0873             break;  // 4x6 = 24
0874         }           //ccctest>0
0875 
0876       }  // for i
0877     }    //if(jeta-41 < 0 )
0878   }      //for jeta
0879   /////////////////
0880   c3x5->Update();
0881   c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth3HB.png");
0882   c3x5->Clear();
0883   // clean-up
0884   if (h2CeffHBnegativedirectionRecosignal3)
0885     delete h2CeffHBnegativedirectionRecosignal3;
0886   //========================================================================================== 1117
0887   //======================================================================
0888   //======================================================================1D plot: R vs phi , different eta,  depth=4
0889   //cout<<"      1D plot: R vs phi , different eta,  depth=4 *****" <<endl;
0890   c3x5->Clear();
0891   /////////////////
0892   c3x5->Divide(4, 4);
0893   c3x5->cd(1);
0894   int kcountHBnegativedirectionRecosignal4 = 1;
0895   TH1F* h2CeffHBnegativedirectionRecosignal4 = new TH1F("h2CeffHBnegativedirectionRecosignal4", "", nphi, 0., 72.);
0896 
0897   for (int jeta = 0; jeta < njeta; jeta++) {
0898     // negativedirectionRecosignal:
0899     if (jeta - 41 < 0) {
0900       //         for (int i=0;i<ndepth;i++) {
0901       // depth=4
0902       for (int i = 3; i < 4; i++) {
0903         TH1F* HBnegativedirectionRecosignal4 = (TH1F*)h2CeffHBnegativedirectionRecosignal4->Clone("twod1");
0904 
0905         float ccctest = 0;  // to avoid empty massive elements
0906         for (int jphi = 0; jphi < nphi; jphi++) {
0907           double ccc1 = arecosignalHB[i][jeta][jphi];
0908           if (ccc1 != 0.) {
0909             HBnegativedirectionRecosignal4->Fill(jphi, ccc1);
0910             ccctest = 1.;  //HBnegativedirectionRecosignal4->SetBinError(i,0.01);
0911           }
0912         }  // for jphi
0913         if (ccctest > 0.) {
0914           //cout<<"777        kcountHBnegativedirectionRecosignal4   =     "<<kcountHBnegativedirectionRecosignal4  <<"   jeta-41=     "<< jeta-41 <<endl;
0915           c3x5->cd(kcountHBnegativedirectionRecosignal4);
0916           HBnegativedirectionRecosignal4->SetMarkerStyle(20);
0917           HBnegativedirectionRecosignal4->SetMarkerSize(0.4);
0918           HBnegativedirectionRecosignal4->GetYaxis()->SetLabelSize(0.04);
0919           HBnegativedirectionRecosignal4->SetXTitle("HBnegativedirectionRecosignal4 \b");
0920           HBnegativedirectionRecosignal4->SetMarkerColor(2);
0921           HBnegativedirectionRecosignal4->SetLineColor(0);
0922           gPad->SetGridy();
0923           gPad->SetGridx();
0924           //       gPad->SetLogy();
0925           if (kcountHBnegativedirectionRecosignal4 == 1)
0926             HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -16; depth = 4 \b");
0927           if (kcountHBnegativedirectionRecosignal4 == 2)
0928             HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -15; depth = 4 \b");
0929           if (kcountHBnegativedirectionRecosignal4 == 3)
0930             HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -14; depth = 4 \b");
0931           if (kcountHBnegativedirectionRecosignal4 == 4)
0932             HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -13; depth = 4 \b");
0933           if (kcountHBnegativedirectionRecosignal4 == 5)
0934             HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -12; depth = 4 \b");
0935           if (kcountHBnegativedirectionRecosignal4 == 6)
0936             HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -11; depth = 4 \b");
0937           if (kcountHBnegativedirectionRecosignal4 == 7)
0938             HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta = -10; depth = 4 \b");
0939           if (kcountHBnegativedirectionRecosignal4 == 8)
0940             HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta =  -9; depth = 4 \b");
0941           if (kcountHBnegativedirectionRecosignal4 == 9)
0942             HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta =  -8; depth = 4 \b");
0943           if (kcountHBnegativedirectionRecosignal4 == 10)
0944             HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta =  -7; depth = 4 \b");
0945           if (kcountHBnegativedirectionRecosignal4 == 11)
0946             HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta =  -6; depth = 4 \b");
0947           if (kcountHBnegativedirectionRecosignal4 == 12)
0948             HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta =  -5; depth = 4 \b");
0949           if (kcountHBnegativedirectionRecosignal4 == 13)
0950             HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta =  -4; depth = 4 \b");
0951           if (kcountHBnegativedirectionRecosignal4 == 14)
0952             HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta =  -3; depth = 4 \b");
0953           if (kcountHBnegativedirectionRecosignal4 == 15)
0954             HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta =  -2; depth = 4 \b");
0955           if (kcountHBnegativedirectionRecosignal4 == 16)
0956             HBnegativedirectionRecosignal4->SetXTitle("R for HB- jeta =  -1; depth = 4 \b");
0957           HBnegativedirectionRecosignal4->Draw("Error");
0958           kcountHBnegativedirectionRecosignal4++;
0959           if (kcountHBnegativedirectionRecosignal4 > 16)
0960             break;  // 4x6 = 24
0961         }           //ccctest>0
0962 
0963       }  // for i
0964     }    //if(jeta-41 < 0 )
0965   }      //for jeta
0966   /////////////////
0967   c3x5->Update();
0968   c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth4HB.png");
0969   c3x5->Clear();
0970   // clean-up
0971   if (h2CeffHBnegativedirectionRecosignal4)
0972     delete h2CeffHBnegativedirectionRecosignal4;
0973 
0974   //======================================================================================================================
0975   //======================================================================================================================
0976   //======================================================================================================================
0977   //                            DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD:
0978 
0979   //cout<<"    Start Vaiance: preparation  *****" <<endl;
0980   TH2F* recosignalVariance1HB1 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy2_HB1");
0981   TH2F* recosignalVariance0HB1 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HB1");
0982   TH2F* recosignalVarianceHB1 = (TH2F*)recosignalVariance1HB1->Clone("recosignalVarianceHB1");
0983   recosignalVarianceHB1->Divide(recosignalVariance1HB1, recosignalVariance0HB1, 1, 1, "B");
0984   TH2F* recosignalVariance1HB2 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy2_HB2");
0985   TH2F* recosignalVariance0HB2 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HB2");
0986   TH2F* recosignalVarianceHB2 = (TH2F*)recosignalVariance1HB2->Clone("recosignalVarianceHB2");
0987   recosignalVarianceHB2->Divide(recosignalVariance1HB2, recosignalVariance0HB2, 1, 1, "B");
0988   TH2F* recosignalVariance1HB3 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy2_HB3");
0989   TH2F* recosignalVariance0HB3 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HB3");
0990   TH2F* recosignalVarianceHB3 = (TH2F*)recosignalVariance1HB3->Clone("recosignalVarianceHB3");
0991   recosignalVarianceHB3->Divide(recosignalVariance1HB3, recosignalVariance0HB3, 1, 1, "B");
0992   TH2F* recosignalVariance1HB4 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy2_HB4");
0993   TH2F* recosignalVariance0HB4 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HB4");
0994   TH2F* recosignalVarianceHB4 = (TH2F*)recosignalVariance1HB4->Clone("recosignalVarianceHB4");
0995   recosignalVarianceHB4->Divide(recosignalVariance1HB4, recosignalVariance0HB4, 1, 1, "B");
0996   //cout<<"      Vaiance: preparation DONE *****" <<endl;
0997   //====================================================================== put Vaiance=Dispersia = Sig**2=<R**2> - (<R>)**2 into massive recosignalvarianceHB
0998   //                                                                                           = sum(R*R)/N - (sum(R)/N)**2
0999   for (int jeta = 0; jeta < njeta; jeta++) {
1000     //preparation for PHI normalization:
1001     double sumrecosignalHB0 = 0;
1002     int nsumrecosignalHB0 = 0;
1003     double sumrecosignalHB1 = 0;
1004     int nsumrecosignalHB1 = 0;
1005     double sumrecosignalHB2 = 0;
1006     int nsumrecosignalHB2 = 0;
1007     double sumrecosignalHB3 = 0;
1008     int nsumrecosignalHB3 = 0;
1009     for (int jphi = 0; jphi < njphi; jphi++) {
1010       recosignalvarianceHB[0][jeta][jphi] = recosignalVarianceHB1->GetBinContent(jeta + 1, jphi + 1);
1011       recosignalvarianceHB[1][jeta][jphi] = recosignalVarianceHB2->GetBinContent(jeta + 1, jphi + 1);
1012       recosignalvarianceHB[2][jeta][jphi] = recosignalVarianceHB3->GetBinContent(jeta + 1, jphi + 1);
1013       recosignalvarianceHB[3][jeta][jphi] = recosignalVarianceHB4->GetBinContent(jeta + 1, jphi + 1);
1014       if (recosignalvarianceHB[0][jeta][jphi] > 0.) {
1015         sumrecosignalHB0 += recosignalvarianceHB[0][jeta][jphi];
1016         ++nsumrecosignalHB0;
1017       }
1018       if (recosignalvarianceHB[1][jeta][jphi] > 0.) {
1019         sumrecosignalHB1 += recosignalvarianceHB[1][jeta][jphi];
1020         ++nsumrecosignalHB1;
1021       }
1022       if (recosignalvarianceHB[2][jeta][jphi] > 0.) {
1023         sumrecosignalHB2 += recosignalvarianceHB[2][jeta][jphi];
1024         ++nsumrecosignalHB2;
1025       }
1026       if (recosignalvarianceHB[3][jeta][jphi] > 0.) {
1027         sumrecosignalHB3 += recosignalvarianceHB[3][jeta][jphi];
1028         ++nsumrecosignalHB3;
1029       }
1030     }  // phi
1031     // PHI normalization :
1032     for (int jphi = 0; jphi < njphi; jphi++) {
1033       if (recosignalvarianceHB[0][jeta][jphi] > 0.)
1034         recosignalvarianceHB[0][jeta][jphi] /= (sumrecosignalHB0 / nsumrecosignalHB0);
1035       if (recosignalvarianceHB[1][jeta][jphi] > 0.)
1036         recosignalvarianceHB[1][jeta][jphi] /= (sumrecosignalHB1 / nsumrecosignalHB1);
1037       if (recosignalvarianceHB[2][jeta][jphi] > 0.)
1038         recosignalvarianceHB[2][jeta][jphi] /= (sumrecosignalHB2 / nsumrecosignalHB2);
1039       if (recosignalvarianceHB[3][jeta][jphi] > 0.)
1040         recosignalvarianceHB[3][jeta][jphi] /= (sumrecosignalHB3 / nsumrecosignalHB3);
1041     }  // phi
1042     //       recosignalvarianceHB (D)           = sum(R*R)/N - (sum(R)/N)**2
1043     for (int jphi = 0; jphi < njphi; jphi++) {
1044       //       cout<<"12 12 12   jeta=     "<< jeta <<"   jphi   =     "<<jphi  <<endl;
1045       recosignalvarianceHB[0][jeta][jphi] -= arecosignalHB[0][jeta][jphi] * arecosignalHB[0][jeta][jphi];
1046       recosignalvarianceHB[0][jeta][jphi] = fabs(recosignalvarianceHB[0][jeta][jphi]);
1047       recosignalvarianceHB[1][jeta][jphi] -= arecosignalHB[1][jeta][jphi] * arecosignalHB[1][jeta][jphi];
1048       recosignalvarianceHB[1][jeta][jphi] = fabs(recosignalvarianceHB[1][jeta][jphi]);
1049       recosignalvarianceHB[2][jeta][jphi] -= arecosignalHB[2][jeta][jphi] * arecosignalHB[2][jeta][jphi];
1050       recosignalvarianceHB[2][jeta][jphi] = fabs(recosignalvarianceHB[2][jeta][jphi]);
1051       recosignalvarianceHB[3][jeta][jphi] -= arecosignalHB[3][jeta][jphi] * arecosignalHB[3][jeta][jphi];
1052       recosignalvarianceHB[3][jeta][jphi] = fabs(recosignalvarianceHB[3][jeta][jphi]);
1053     }
1054   }
1055   //cout<<"      Vaiance: DONE*****" <<endl;
1056   //------------------------  2D-eta/phi-plot: D, averaged over depthfs
1057   //======================================================================
1058   //======================================================================
1059   //cout<<"      R2D-eta/phi-plot: D, averaged over depthfs *****" <<endl;
1060   c1x1->Clear();
1061   /////////////////
1062   c1x0->Divide(1, 1);
1063   c1x0->cd(1);
1064   TH2F* DefzDrecosignalHB42D = new TH2F("DefzDrecosignalHB42D", "", neta, -41., 41., nphi, 0., 72.);
1065   TH2F* DefzDrecosignalHB42D0 = new TH2F("DefzDrecosignalHB42D0", "", neta, -41., 41., nphi, 0., 72.);
1066   TH2F* DefzDrecosignalHB42DF = (TH2F*)DefzDrecosignalHB42D0->Clone("DefzDrecosignalHB42DF");
1067   for (int i = 0; i < ndepth; i++) {
1068     for (int jeta = 0; jeta < neta; jeta++) {
1069       for (int jphi = 0; jphi < nphi; jphi++) {
1070         double ccc1 = recosignalvarianceHB[i][jeta][jphi];
1071         int k2plot = jeta - 41;
1072         int kkk = k2plot;  //if(k2plot >0   kkk=k2plot+1; //-41 +41 !=0
1073         if (arecosignalHB[i][jeta][jphi] > 0.) {
1074           DefzDrecosignalHB42D->Fill(kkk, jphi, ccc1);
1075           DefzDrecosignalHB42D0->Fill(kkk, jphi, 1.);
1076         }
1077       }
1078     }
1079   }
1080   DefzDrecosignalHB42DF->Divide(DefzDrecosignalHB42D, DefzDrecosignalHB42D0, 1, 1, "B");  // average A
1081   //    DefzDrecosignalHB1->Sumw2();
1082   gPad->SetGridy();
1083   gPad->SetGridx();  //      gPad->SetLogz();
1084   DefzDrecosignalHB42DF->SetMarkerStyle(20);
1085   DefzDrecosignalHB42DF->SetMarkerSize(0.4);
1086   DefzDrecosignalHB42DF->GetZaxis()->SetLabelSize(0.08);
1087   DefzDrecosignalHB42DF->SetXTitle("<D>_depth       #eta  \b");
1088   DefzDrecosignalHB42DF->SetYTitle("      #phi \b");
1089   DefzDrecosignalHB42DF->SetZTitle("<D>_depth \b");
1090   DefzDrecosignalHB42DF->SetMarkerColor(2);
1091   DefzDrecosignalHB42DF->SetLineColor(
1092       0);  //      DefzDrecosignalHB42DF->SetMaximum(1.000);  //      DefzDrecosignalHB42DF->SetMinimum(1.0);
1093   DefzDrecosignalHB42DF->Draw("COLZ");
1094   /////////////////
1095   c1x0->Update();
1096   c1x0->Print("DrecosignalGeneralD2PhiSymmetryHB.png");
1097   c1x0->Clear();
1098   // clean-up
1099   if (DefzDrecosignalHB42D)
1100     delete DefzDrecosignalHB42D;
1101   if (DefzDrecosignalHB42D0)
1102     delete DefzDrecosignalHB42D0;
1103   if (DefzDrecosignalHB42DF)
1104     delete DefzDrecosignalHB42DF;
1105   //====================================================================== 1D plot: D vs phi , averaged over depthfs & eta
1106   //======================================================================
1107   //cout<<"      1D plot: D vs phi , averaged over depthfs & eta *****" <<endl;
1108   c1x1->Clear();
1109   /////////////////
1110   c1x1->Divide(1, 1);
1111   c1x1->cd(1);
1112   TH1F* DefzDrecosignalHB41D = new TH1F("DefzDrecosignalHB41D", "", nphi, 0., 72.);
1113   TH1F* DefzDrecosignalHB41D0 = new TH1F("DefzDrecosignalHB41D0", "", nphi, 0., 72.);
1114   TH1F* DefzDrecosignalHB41DF = (TH1F*)DefzDrecosignalHB41D0->Clone("DefzDrecosignalHB41DF");
1115 
1116   for (int jphi = 0; jphi < nphi; jphi++) {
1117     for (int jeta = 0; jeta < neta; jeta++) {
1118       for (int i = 0; i < ndepth; i++) {
1119         double ccc1 = recosignalvarianceHB[i][jeta][jphi];
1120         if (arecosignalHB[i][jeta][jphi] > 0.) {
1121           DefzDrecosignalHB41D->Fill(jphi, ccc1);
1122           DefzDrecosignalHB41D0->Fill(jphi, 1.);
1123         }
1124       }
1125     }
1126   }
1127   //     DefzDrecosignalHB41D->Sumw2();DefzDrecosignalHB41D0->Sumw2();
1128 
1129   DefzDrecosignalHB41DF->Divide(
1130       DefzDrecosignalHB41D, DefzDrecosignalHB41D0, 1, 1, "B");  // R averaged over depthfs & eta
1131   DefzDrecosignalHB41D0->Sumw2();
1132   //    for (int jphi=1;jphi<73;jphi++) {DefzDrecosignalHB41DF->SetBinError(jphi,0.01);}
1133   gPad->SetGridy();
1134   gPad->SetGridx();  //      gPad->SetLogz();
1135   DefzDrecosignalHB41DF->SetMarkerStyle(20);
1136   DefzDrecosignalHB41DF->SetMarkerSize(1.4);
1137   DefzDrecosignalHB41DF->GetZaxis()->SetLabelSize(0.08);
1138   DefzDrecosignalHB41DF->SetXTitle("#phi  \b");
1139   DefzDrecosignalHB41DF->SetYTitle("  <D> \b");
1140   DefzDrecosignalHB41DF->SetZTitle("<D>_PHI  - AllDepthfs \b");
1141   DefzDrecosignalHB41DF->SetMarkerColor(4);
1142   DefzDrecosignalHB41DF->SetLineColor(
1143       4);  //  DefzDrecosignalHB41DF->SetMinimum(0.8);     DefzDrecosignalHB41DF->SetMinimum(-0.015);
1144   DefzDrecosignalHB41DF->Draw("Error");
1145   /////////////////
1146   c1x1->Update();
1147   c1x1->Print("DrecosignalGeneralD1PhiSymmetryHB.png");
1148   c1x1->Clear();
1149   // clean-up
1150   if (DefzDrecosignalHB41D)
1151     delete DefzDrecosignalHB41D;
1152   if (DefzDrecosignalHB41D0)
1153     delete DefzDrecosignalHB41D0;
1154   if (DefzDrecosignalHB41DF)
1155     delete DefzDrecosignalHB41DF;
1156 
1157   //========================================================================================== 14
1158   //======================================================================
1159   //======================================================================1D plot: D vs phi , different eta,  depth=1
1160   //cout<<"      1D plot: D vs phi , different eta,  depth=1 *****" <<endl;
1161   c3x5->Clear();
1162   /////////////////
1163   c3x5->Divide(4, 4);
1164   c3x5->cd(1);
1165   int kcountHBpositivedirectionRecosignalD1 = 1;
1166   TH1F* h2CeffHBpositivedirectionRecosignalD1 = new TH1F("h2CeffHBpositivedirectionRecosignalD1", "", nphi, 0., 72.);
1167 
1168   for (int jeta = 0; jeta < njeta; jeta++) {
1169     // positivedirectionRecosignalD:
1170     if (jeta - 41 >= 0) {
1171       //         for (int i=0;i<ndepth;i++) {
1172       // depth=1
1173       for (int i = 0; i < 1; i++) {
1174         TH1F* HBpositivedirectionRecosignalD1 = (TH1F*)h2CeffHBpositivedirectionRecosignalD1->Clone("twod1");
1175 
1176         float ccctest = 0;  // to avoid empty massive elements
1177         for (int jphi = 0; jphi < nphi; jphi++) {
1178           double ccc1 = recosignalvarianceHB[i][jeta][jphi];
1179           if (arecosignalHB[i][jeta][jphi] > 0.) {
1180             HBpositivedirectionRecosignalD1->Fill(jphi, ccc1);
1181             ccctest = 1.;  //HBpositivedirectionRecosignalD1->SetBinError(i,0.01);
1182           }
1183         }  // for jphi
1184         if (ccctest > 0.) {
1185           //cout<<"1414       kcountHBpositivedirectionRecosignalD1   =     "<<kcountHBpositivedirectionRecosignalD1  <<"   jeta-41=     "<< jeta-41 <<endl;
1186           c3x5->cd(kcountHBpositivedirectionRecosignalD1);
1187           HBpositivedirectionRecosignalD1->SetMarkerStyle(20);
1188           HBpositivedirectionRecosignalD1->SetMarkerSize(0.4);
1189           HBpositivedirectionRecosignalD1->GetYaxis()->SetLabelSize(0.04);
1190           HBpositivedirectionRecosignalD1->SetXTitle("HBpositivedirectionRecosignalD1 \b");
1191           HBpositivedirectionRecosignalD1->SetMarkerColor(2);
1192           HBpositivedirectionRecosignalD1->SetLineColor(0);
1193           gPad->SetGridy();
1194           gPad->SetGridx();
1195           //       gPad->SetLogy();
1196           if (kcountHBpositivedirectionRecosignalD1 == 1)
1197             HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta =  0; depth = 1 \b");
1198           if (kcountHBpositivedirectionRecosignalD1 == 2)
1199             HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta =  1; depth = 1 \b");
1200           if (kcountHBpositivedirectionRecosignalD1 == 3)
1201             HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta =  2; depth = 1 \b");
1202           if (kcountHBpositivedirectionRecosignalD1 == 4)
1203             HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta =  3; depth = 1 \b");
1204           if (kcountHBpositivedirectionRecosignalD1 == 5)
1205             HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta =  4; depth = 1 \b");
1206           if (kcountHBpositivedirectionRecosignalD1 == 6)
1207             HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta =  5; depth = 1 \b");
1208           if (kcountHBpositivedirectionRecosignalD1 == 7)
1209             HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta =  6; depth = 1 \b");
1210           if (kcountHBpositivedirectionRecosignalD1 == 8)
1211             HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta =  7; depth = 1 \b");
1212           if (kcountHBpositivedirectionRecosignalD1 == 9)
1213             HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta =  8; depth = 1 \b");
1214           if (kcountHBpositivedirectionRecosignalD1 == 10)
1215             HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta =  9; depth = 1 \b");
1216           if (kcountHBpositivedirectionRecosignalD1 == 11)
1217             HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 10; depth = 1 \b");
1218           if (kcountHBpositivedirectionRecosignalD1 == 12)
1219             HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 11; depth = 1 \b");
1220           if (kcountHBpositivedirectionRecosignalD1 == 13)
1221             HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 12; depth = 1 \b");
1222           if (kcountHBpositivedirectionRecosignalD1 == 14)
1223             HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 13; depth = 1 \b");
1224           if (kcountHBpositivedirectionRecosignalD1 == 15)
1225             HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 14; depth = 1 \b");
1226           if (kcountHBpositivedirectionRecosignalD1 == 16)
1227             HBpositivedirectionRecosignalD1->SetXTitle("D for HB+ jeta = 15; depth = 1 \b");
1228           HBpositivedirectionRecosignalD1->Draw("Error");
1229           kcountHBpositivedirectionRecosignalD1++;
1230           if (kcountHBpositivedirectionRecosignalD1 > 16)
1231             break;  // 4x6 = 24
1232         }           //ccctest>0
1233 
1234       }  // for i
1235     }    //if(jeta-41 >= 0)
1236   }      //for jeta
1237   /////////////////
1238   c3x5->Update();
1239   c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth1HB.png");
1240   c3x5->Clear();
1241   // clean-up
1242   if (h2CeffHBpositivedirectionRecosignalD1)
1243     delete h2CeffHBpositivedirectionRecosignalD1;
1244   //========================================================================================== 15
1245   //======================================================================
1246   //======================================================================1D plot: D vs phi , different eta,  depth=2
1247   //cout<<"      1D plot: D vs phi , different eta,  depth=2 *****" <<endl;
1248   c3x5->Clear();
1249   c3x5->Divide(4, 4);
1250   c3x5->cd(1);
1251   int kcountHBpositivedirectionRecosignalD2 = 1;
1252   TH1F* h2CeffHBpositivedirectionRecosignalD2 = new TH1F("h2CeffHBpositivedirectionRecosignalD2", "", nphi, 0., 72.);
1253 
1254   for (int jeta = 0; jeta < njeta; jeta++) {
1255     // positivedirectionRecosignalD:
1256     if (jeta - 41 >= 0) {
1257       //         for (int i=0;i<ndepth;i++) {
1258       // depth=2
1259       for (int i = 1; i < 2; i++) {
1260         TH1F* HBpositivedirectionRecosignalD2 = (TH1F*)h2CeffHBpositivedirectionRecosignalD2->Clone("twod1");
1261 
1262         float ccctest = 0;  // to avoid empty massive elements
1263         for (int jphi = 0; jphi < nphi; jphi++) {
1264           double ccc1 = recosignalvarianceHB[i][jeta][jphi];
1265           if (arecosignalHB[i][jeta][jphi] > 0.) {
1266             HBpositivedirectionRecosignalD2->Fill(jphi, ccc1);
1267             ccctest = 1.;  //HBpositivedirectionRecosignalD2->SetBinError(i,0.01);
1268           }
1269         }  // for jphi
1270         if (ccctest > 0.) {
1271           //cout<<"1515       kcountHBpositivedirectionRecosignalD2   =     "<<kcountHBpositivedirectionRecosignalD2  <<"   jeta-41=     "<< jeta-41 <<endl;
1272           c3x5->cd(kcountHBpositivedirectionRecosignalD2);
1273           HBpositivedirectionRecosignalD2->SetMarkerStyle(20);
1274           HBpositivedirectionRecosignalD2->SetMarkerSize(0.4);
1275           HBpositivedirectionRecosignalD2->GetYaxis()->SetLabelSize(0.04);
1276           HBpositivedirectionRecosignalD2->SetXTitle("HBpositivedirectionRecosignalD2 \b");
1277           HBpositivedirectionRecosignalD2->SetMarkerColor(2);
1278           HBpositivedirectionRecosignalD2->SetLineColor(0);
1279           gPad->SetGridy();
1280           gPad->SetGridx();
1281           //       gPad->SetLogy();
1282           if (kcountHBpositivedirectionRecosignalD2 == 1)
1283             HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta =  0; depth = 2 \b");
1284           if (kcountHBpositivedirectionRecosignalD2 == 2)
1285             HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta =  1; depth = 2 \b");
1286           if (kcountHBpositivedirectionRecosignalD2 == 3)
1287             HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta =  2; depth = 2 \b");
1288           if (kcountHBpositivedirectionRecosignalD2 == 4)
1289             HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta =  3; depth = 2 \b");
1290           if (kcountHBpositivedirectionRecosignalD2 == 5)
1291             HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta =  4; depth = 2 \b");
1292           if (kcountHBpositivedirectionRecosignalD2 == 6)
1293             HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta =  5; depth = 2 \b");
1294           if (kcountHBpositivedirectionRecosignalD2 == 7)
1295             HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta =  6; depth = 2 \b");
1296           if (kcountHBpositivedirectionRecosignalD2 == 8)
1297             HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta =  7; depth = 2 \b");
1298           if (kcountHBpositivedirectionRecosignalD2 == 9)
1299             HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta =  8; depth = 2 \b");
1300           if (kcountHBpositivedirectionRecosignalD2 == 10)
1301             HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta =  9; depth = 2 \b");
1302           if (kcountHBpositivedirectionRecosignalD2 == 11)
1303             HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 10; depth = 2 \b");
1304           if (kcountHBpositivedirectionRecosignalD2 == 12)
1305             HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 11; depth = 2 \b");
1306           if (kcountHBpositivedirectionRecosignalD2 == 13)
1307             HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 12; depth = 2 \b");
1308           if (kcountHBpositivedirectionRecosignalD2 == 14)
1309             HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 13; depth = 2 \b");
1310           if (kcountHBpositivedirectionRecosignalD2 == 15)
1311             HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 14; depth = 2 \b");
1312           if (kcountHBpositivedirectionRecosignalD2 == 16)
1313             HBpositivedirectionRecosignalD2->SetXTitle("D for HB+ jeta = 15; depth = 2 \b");
1314           HBpositivedirectionRecosignalD2->Draw("Error");
1315           kcountHBpositivedirectionRecosignalD2++;
1316           if (kcountHBpositivedirectionRecosignalD2 > 16)
1317             break;  // 4x6 = 24
1318         }           //ccctest>0
1319 
1320       }  // for i
1321     }    //if(jeta-41 >= 0)
1322   }      //for jeta
1323   /////////////////
1324   c3x5->Update();
1325   c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth2HB.png");
1326   c3x5->Clear();
1327   // clean-up
1328   if (h2CeffHBpositivedirectionRecosignalD2)
1329     delete h2CeffHBpositivedirectionRecosignalD2;
1330   //========================================================================================== 16
1331   //======================================================================
1332   //======================================================================1D plot: D vs phi , different eta,  depth=3
1333   //cout<<"      1D plot: D vs phi , different eta,  depth=3 *****" <<endl;
1334   c3x5->Clear();
1335   c3x5->Divide(4, 4);
1336   c3x5->cd(1);
1337   int kcountHBpositivedirectionRecosignalD3 = 1;
1338   TH1F* h2CeffHBpositivedirectionRecosignalD3 = new TH1F("h2CeffHBpositivedirectionRecosignalD3", "", nphi, 0., 72.);
1339 
1340   for (int jeta = 0; jeta < njeta; jeta++) {
1341     // positivedirectionRecosignalD:
1342     if (jeta - 41 >= 0) {
1343       //         for (int i=0;i<ndepth;i++) {
1344       // depth=3
1345       for (int i = 2; i < 3; i++) {
1346         TH1F* HBpositivedirectionRecosignalD3 = (TH1F*)h2CeffHBpositivedirectionRecosignalD3->Clone("twod1");
1347 
1348         float ccctest = 0;  // to avoid empty massive elements
1349         for (int jphi = 0; jphi < nphi; jphi++) {
1350           double ccc1 = recosignalvarianceHB[i][jeta][jphi];
1351           if (arecosignalHB[i][jeta][jphi] > 0.) {
1352             HBpositivedirectionRecosignalD3->Fill(jphi, ccc1);
1353             ccctest = 1.;  //HBpositivedirectionRecosignalD3->SetBinError(i,0.01);
1354           }
1355         }  // for jphi
1356         if (ccctest > 0.) {
1357           //cout<<"1616       kcountHBpositivedirectionRecosignalD3   =     "<<kcountHBpositivedirectionRecosignalD3  <<"   jeta-41=     "<< jeta-41 <<endl;
1358           c3x5->cd(kcountHBpositivedirectionRecosignalD3);
1359           HBpositivedirectionRecosignalD3->SetMarkerStyle(20);
1360           HBpositivedirectionRecosignalD3->SetMarkerSize(0.4);
1361           HBpositivedirectionRecosignalD3->GetYaxis()->SetLabelSize(0.04);
1362           HBpositivedirectionRecosignalD3->SetXTitle("HBpositivedirectionRecosignalD3 \b");
1363           HBpositivedirectionRecosignalD3->SetMarkerColor(2);
1364           HBpositivedirectionRecosignalD3->SetLineColor(0);
1365           gPad->SetGridy();
1366           gPad->SetGridx();
1367           //       gPad->SetLogy();
1368           if (kcountHBpositivedirectionRecosignalD3 == 1)
1369             HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta =  0; depth = 3 \b");
1370           if (kcountHBpositivedirectionRecosignalD3 == 2)
1371             HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta =  1; depth = 3 \b");
1372           if (kcountHBpositivedirectionRecosignalD3 == 3)
1373             HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta =  2; depth = 3 \b");
1374           if (kcountHBpositivedirectionRecosignalD3 == 4)
1375             HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta =  3; depth = 3 \b");
1376           if (kcountHBpositivedirectionRecosignalD3 == 5)
1377             HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta =  4; depth = 3 \b");
1378           if (kcountHBpositivedirectionRecosignalD3 == 6)
1379             HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta =  5; depth = 3 \b");
1380           if (kcountHBpositivedirectionRecosignalD3 == 7)
1381             HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta =  6; depth = 3 \b");
1382           if (kcountHBpositivedirectionRecosignalD3 == 8)
1383             HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta =  7; depth = 3 \b");
1384           if (kcountHBpositivedirectionRecosignalD3 == 9)
1385             HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta =  8; depth = 3 \b");
1386           if (kcountHBpositivedirectionRecosignalD3 == 10)
1387             HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta =  9; depth = 3 \b");
1388           if (kcountHBpositivedirectionRecosignalD3 == 11)
1389             HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 10; depth = 3 \b");
1390           if (kcountHBpositivedirectionRecosignalD3 == 12)
1391             HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 11; depth = 3 \b");
1392           if (kcountHBpositivedirectionRecosignalD3 == 13)
1393             HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 12; depth = 3 \b");
1394           if (kcountHBpositivedirectionRecosignalD3 == 14)
1395             HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 13; depth = 3 \b");
1396           if (kcountHBpositivedirectionRecosignalD3 == 15)
1397             HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 14; depth = 3 \b");
1398           if (kcountHBpositivedirectionRecosignalD3 == 16)
1399             HBpositivedirectionRecosignalD3->SetXTitle("D for HB+ jeta = 15; depth = 3 \b");
1400           HBpositivedirectionRecosignalD3->Draw("Error");
1401           kcountHBpositivedirectionRecosignalD3++;
1402           if (kcountHBpositivedirectionRecosignalD3 > 16)
1403             break;  // 4x6 = 24
1404         }           //ccctest>0
1405 
1406       }  // for i
1407     }    //if(jeta-41 >= 0)
1408   }      //for jeta
1409   /////////////////
1410   c3x5->Update();
1411   c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth3HB.png");
1412   c3x5->Clear();
1413   // clean-up
1414   if (h2CeffHBpositivedirectionRecosignalD3)
1415     delete h2CeffHBpositivedirectionRecosignalD3;
1416   //========================================================================================== 17
1417   //======================================================================
1418   //======================================================================1D plot: D vs phi , different eta,  depth=4
1419   //cout<<"      1D plot: D vs phi , different eta,  depth=4 *****" <<endl;
1420   c3x5->Clear();
1421   c3x5->Divide(4, 4);
1422   c3x5->cd(1);
1423   int kcountHBpositivedirectionRecosignalD4 = 1;
1424   TH1F* h2CeffHBpositivedirectionRecosignalD4 = new TH1F("h2CeffHBpositivedirectionRecosignalD4", "", nphi, 0., 72.);
1425 
1426   for (int jeta = 0; jeta < njeta; jeta++) {
1427     // positivedirectionRecosignalD:
1428     if (jeta - 41 >= 0) {
1429       //         for (int i=0;i<ndepth;i++) {
1430       // depth=4
1431       for (int i = 3; i < 4; i++) {
1432         TH1F* HBpositivedirectionRecosignalD4 = (TH1F*)h2CeffHBpositivedirectionRecosignalD4->Clone("twod1");
1433 
1434         float ccctest = 0;  // to avoid empty massive elements
1435         for (int jphi = 0; jphi < nphi; jphi++) {
1436           double ccc1 = recosignalvarianceHB[i][jeta][jphi];
1437           if (arecosignalHB[i][jeta][jphi] > 0.) {
1438             HBpositivedirectionRecosignalD4->Fill(jphi, ccc1);
1439             ccctest = 1.;  //HBpositivedirectionRecosignalD4->SetBinError(i,0.01);
1440           }
1441         }  // for jphi
1442         if (ccctest > 0.) {
1443           //cout<<"1717       kcountHBpositivedirectionRecosignalD4   =     "<<kcountHBpositivedirectionRecosignalD4  <<"   jeta-41=     "<< jeta-41 <<endl;
1444           c3x5->cd(kcountHBpositivedirectionRecosignalD4);
1445           HBpositivedirectionRecosignalD4->SetMarkerStyle(20);
1446           HBpositivedirectionRecosignalD4->SetMarkerSize(0.4);
1447           HBpositivedirectionRecosignalD4->GetYaxis()->SetLabelSize(0.04);
1448           HBpositivedirectionRecosignalD4->SetXTitle("HBpositivedirectionRecosignalD4 \b");
1449           HBpositivedirectionRecosignalD4->SetMarkerColor(2);
1450           HBpositivedirectionRecosignalD4->SetLineColor(0);
1451           gPad->SetGridy();
1452           gPad->SetGridx();
1453           //       gPad->SetLogy();
1454           if (kcountHBpositivedirectionRecosignalD4 == 1)
1455             HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta =  0; depth = 4 \b");
1456           if (kcountHBpositivedirectionRecosignalD4 == 2)
1457             HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta =  1; depth = 4 \b");
1458           if (kcountHBpositivedirectionRecosignalD4 == 3)
1459             HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta =  2; depth = 4 \b");
1460           if (kcountHBpositivedirectionRecosignalD4 == 4)
1461             HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta =  3; depth = 4 \b");
1462           if (kcountHBpositivedirectionRecosignalD4 == 5)
1463             HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta =  4; depth = 4 \b");
1464           if (kcountHBpositivedirectionRecosignalD4 == 6)
1465             HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta =  5; depth = 4 \b");
1466           if (kcountHBpositivedirectionRecosignalD4 == 7)
1467             HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta =  6; depth = 4 \b");
1468           if (kcountHBpositivedirectionRecosignalD4 == 8)
1469             HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta =  7; depth = 4 \b");
1470           if (kcountHBpositivedirectionRecosignalD4 == 9)
1471             HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta =  8; depth = 4 \b");
1472           if (kcountHBpositivedirectionRecosignalD4 == 10)
1473             HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta =  9; depth = 4 \b");
1474           if (kcountHBpositivedirectionRecosignalD4 == 11)
1475             HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 10; depth = 4 \b");
1476           if (kcountHBpositivedirectionRecosignalD4 == 12)
1477             HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 11; depth = 4 \b");
1478           if (kcountHBpositivedirectionRecosignalD4 == 13)
1479             HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 12; depth = 4 \b");
1480           if (kcountHBpositivedirectionRecosignalD4 == 14)
1481             HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 13; depth = 4 \b");
1482           if (kcountHBpositivedirectionRecosignalD4 == 15)
1483             HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 14; depth = 4 \b");
1484           if (kcountHBpositivedirectionRecosignalD4 == 16)
1485             HBpositivedirectionRecosignalD4->SetXTitle("D for HB+ jeta = 15; depth = 4 \b");
1486           HBpositivedirectionRecosignalD4->Draw("Error");
1487           kcountHBpositivedirectionRecosignalD4++;
1488           if (kcountHBpositivedirectionRecosignalD4 > 16)
1489             break;  // 4x6 = 24
1490         }           //ccctest>0
1491 
1492       }  // for i
1493     }    //if(jeta-41 >= 0)
1494   }      //for jeta
1495   /////////////////
1496   c3x5->Update();
1497   c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth4HB.png");
1498   c3x5->Clear();
1499   // clean-up
1500   if (h2CeffHBpositivedirectionRecosignalD4)
1501     delete h2CeffHBpositivedirectionRecosignalD4;
1502 
1503   //========================================================================================== 22214
1504   //======================================================================
1505   //======================================================================1D plot: D vs phi , different eta,  depth=1
1506   //cout<<"      1D plot: D vs phi , different eta,  depth=1 *****" <<endl;
1507   c3x5->Clear();
1508   /////////////////
1509   c3x5->Divide(4, 4);
1510   c3x5->cd(1);
1511   int kcountHBnegativedirectionRecosignalD1 = 1;
1512   TH1F* h2CeffHBnegativedirectionRecosignalD1 = new TH1F("h2CeffHBnegativedirectionRecosignalD1", "", nphi, 0., 72.);
1513 
1514   for (int jeta = 0; jeta < njeta; jeta++) {
1515     // negativedirectionRecosignalD:
1516     if (jeta - 41 < 0) {
1517       //         for (int i=0;i<ndepth;i++) {
1518       // depth=1
1519       for (int i = 0; i < 1; i++) {
1520         TH1F* HBnegativedirectionRecosignalD1 = (TH1F*)h2CeffHBnegativedirectionRecosignalD1->Clone("twod1");
1521 
1522         float ccctest = 0;  // to avoid empty massive elements
1523         for (int jphi = 0; jphi < nphi; jphi++) {
1524           double ccc1 = recosignalvarianceHB[i][jeta][jphi];
1525           if (arecosignalHB[i][jeta][jphi] > 0.) {
1526             HBnegativedirectionRecosignalD1->Fill(jphi, ccc1);
1527             ccctest = 1.;  //HBnegativedirectionRecosignalD1->SetBinError(i,0.01);
1528           }
1529         }  // for jphi
1530         if (ccctest > 0.) {
1531           //cout<<"1414       kcountHBnegativedirectionRecosignalD1   =     "<<kcountHBnegativedirectionRecosignalD1  <<"   jeta-41=     "<< jeta-41 <<endl;
1532           c3x5->cd(kcountHBnegativedirectionRecosignalD1);
1533           HBnegativedirectionRecosignalD1->SetMarkerStyle(20);
1534           HBnegativedirectionRecosignalD1->SetMarkerSize(0.4);
1535           HBnegativedirectionRecosignalD1->GetYaxis()->SetLabelSize(0.04);
1536           HBnegativedirectionRecosignalD1->SetXTitle("HBnegativedirectionRecosignalD1 \b");
1537           HBnegativedirectionRecosignalD1->SetMarkerColor(2);
1538           HBnegativedirectionRecosignalD1->SetLineColor(0);
1539           gPad->SetGridy();
1540           gPad->SetGridx();
1541           //       gPad->SetLogy();
1542           if (kcountHBnegativedirectionRecosignalD1 == 1)
1543             HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -16; depth = 1 \b");
1544           if (kcountHBnegativedirectionRecosignalD1 == 2)
1545             HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -15; depth = 1 \b");
1546           if (kcountHBnegativedirectionRecosignalD1 == 3)
1547             HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -14; depth = 1 \b");
1548           if (kcountHBnegativedirectionRecosignalD1 == 4)
1549             HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -13; depth = 1 \b");
1550           if (kcountHBnegativedirectionRecosignalD1 == 5)
1551             HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -12; depth = 1 \b");
1552           if (kcountHBnegativedirectionRecosignalD1 == 6)
1553             HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -11; depth = 1 \b");
1554           if (kcountHBnegativedirectionRecosignalD1 == 7)
1555             HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta = -10; depth = 1 \b");
1556           if (kcountHBnegativedirectionRecosignalD1 == 8)
1557             HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta =  -9; depth = 1 \b");
1558           if (kcountHBnegativedirectionRecosignalD1 == 9)
1559             HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta =  -8; depth = 1 \b");
1560           if (kcountHBnegativedirectionRecosignalD1 == 10)
1561             HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta =  -7; depth = 1 \b");
1562           if (kcountHBnegativedirectionRecosignalD1 == 11)
1563             HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta =  -6; depth = 1 \b");
1564           if (kcountHBnegativedirectionRecosignalD1 == 12)
1565             HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta =  -5; depth = 1 \b");
1566           if (kcountHBnegativedirectionRecosignalD1 == 13)
1567             HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta =  -4; depth = 1 \b");
1568           if (kcountHBnegativedirectionRecosignalD1 == 14)
1569             HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta =  -3; depth = 1 \b");
1570           if (kcountHBnegativedirectionRecosignalD1 == 15)
1571             HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta =  -2; depth = 1 \b");
1572           if (kcountHBnegativedirectionRecosignalD1 == 16)
1573             HBnegativedirectionRecosignalD1->SetXTitle("D for HB- jeta =  -1; depth = 1 \b");
1574           HBnegativedirectionRecosignalD1->Draw("Error");
1575           kcountHBnegativedirectionRecosignalD1++;
1576           if (kcountHBnegativedirectionRecosignalD1 > 16)
1577             break;  // 4x6 = 24
1578         }           //ccctest>0
1579 
1580       }  // for i
1581     }    //if(jeta-41 < 0)
1582   }      //for jeta
1583   /////////////////
1584   c3x5->Update();
1585   c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth1HB.png");
1586   c3x5->Clear();
1587   // clean-up
1588   if (h2CeffHBnegativedirectionRecosignalD1)
1589     delete h2CeffHBnegativedirectionRecosignalD1;
1590   //========================================================================================== 22215
1591   //======================================================================
1592   //======================================================================1D plot: D vs phi , different eta,  depth=2
1593   //cout<<"      1D plot: D vs phi , different eta,  depth=2 *****" <<endl;
1594   c3x5->Clear();
1595   c3x5->Divide(4, 4);
1596   c3x5->cd(1);
1597   int kcountHBnegativedirectionRecosignalD2 = 1;
1598   TH1F* h2CeffHBnegativedirectionRecosignalD2 = new TH1F("h2CeffHBnegativedirectionRecosignalD2", "", nphi, 0., 72.);
1599 
1600   for (int jeta = 0; jeta < njeta; jeta++) {
1601     // negativedirectionRecosignalD:
1602     if (jeta - 41 < 0) {
1603       //         for (int i=0;i<ndepth;i++) {
1604       // depth=2
1605       for (int i = 1; i < 2; i++) {
1606         TH1F* HBnegativedirectionRecosignalD2 = (TH1F*)h2CeffHBnegativedirectionRecosignalD2->Clone("twod1");
1607 
1608         float ccctest = 0;  // to avoid empty massive elements
1609         for (int jphi = 0; jphi < nphi; jphi++) {
1610           double ccc1 = recosignalvarianceHB[i][jeta][jphi];
1611           if (arecosignalHB[i][jeta][jphi] > 0.) {
1612             HBnegativedirectionRecosignalD2->Fill(jphi, ccc1);
1613             ccctest = 1.;  //HBnegativedirectionRecosignalD2->SetBinError(i,0.01);
1614           }
1615         }  // for jphi
1616         if (ccctest > 0.) {
1617           //cout<<"1515       kcountHBnegativedirectionRecosignalD2   =     "<<kcountHBnegativedirectionRecosignalD2  <<"   jeta-41=     "<< jeta-41 <<endl;
1618           c3x5->cd(kcountHBnegativedirectionRecosignalD2);
1619           HBnegativedirectionRecosignalD2->SetMarkerStyle(20);
1620           HBnegativedirectionRecosignalD2->SetMarkerSize(0.4);
1621           HBnegativedirectionRecosignalD2->GetYaxis()->SetLabelSize(0.04);
1622           HBnegativedirectionRecosignalD2->SetXTitle("HBnegativedirectionRecosignalD2 \b");
1623           HBnegativedirectionRecosignalD2->SetMarkerColor(2);
1624           HBnegativedirectionRecosignalD2->SetLineColor(0);
1625           gPad->SetGridy();
1626           gPad->SetGridx();
1627           //       gPad->SetLogy();
1628           if (kcountHBnegativedirectionRecosignalD2 == 1)
1629             HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-16; depth = 2 \b");
1630           if (kcountHBnegativedirectionRecosignalD2 == 2)
1631             HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-15; depth = 2 \b");
1632           if (kcountHBnegativedirectionRecosignalD2 == 3)
1633             HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-14; depth = 2 \b");
1634           if (kcountHBnegativedirectionRecosignalD2 == 4)
1635             HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-13; depth = 2 \b");
1636           if (kcountHBnegativedirectionRecosignalD2 == 5)
1637             HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-12; depth = 2 \b");
1638           if (kcountHBnegativedirectionRecosignalD2 == 6)
1639             HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-11; depth = 2 \b");
1640           if (kcountHBnegativedirectionRecosignalD2 == 7)
1641             HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-10; depth = 2 \b");
1642           if (kcountHBnegativedirectionRecosignalD2 == 8)
1643             HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-9 ; depth = 2 \b");
1644           if (kcountHBnegativedirectionRecosignalD2 == 9)
1645             HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-8 ; depth = 2 \b");
1646           if (kcountHBnegativedirectionRecosignalD2 == 10)
1647             HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-7 ; depth = 2 \b");
1648           if (kcountHBnegativedirectionRecosignalD2 == 11)
1649             HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-6 ; depth = 2 \b");
1650           if (kcountHBnegativedirectionRecosignalD2 == 12)
1651             HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-5 ; depth = 2 \b");
1652           if (kcountHBnegativedirectionRecosignalD2 == 13)
1653             HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-4 ; depth = 2 \b");
1654           if (kcountHBnegativedirectionRecosignalD2 == 14)
1655             HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-3 ; depth = 2 \b");
1656           if (kcountHBnegativedirectionRecosignalD2 == 15)
1657             HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-2 ; depth = 2 \b");
1658           if (kcountHBnegativedirectionRecosignalD2 == 16)
1659             HBnegativedirectionRecosignalD2->SetXTitle("D for HB- jeta =-1 ; depth = 2 \b");
1660           HBnegativedirectionRecosignalD2->Draw("Error");
1661           kcountHBnegativedirectionRecosignalD2++;
1662           if (kcountHBnegativedirectionRecosignalD2 > 16)
1663             break;  // 4x6 = 24
1664         }           //ccctest>0
1665 
1666       }  // for i
1667     }    //if(jeta-41 < 0)
1668   }      //for jeta
1669   /////////////////
1670   c3x5->Update();
1671   c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth2HB.png");
1672   c3x5->Clear();
1673   // clean-up
1674   if (h2CeffHBnegativedirectionRecosignalD2)
1675     delete h2CeffHBnegativedirectionRecosignalD2;
1676   //========================================================================================== 22216
1677   //======================================================================
1678   //======================================================================1D plot: D vs phi , different eta,  depth=3
1679   //cout<<"      1D plot: D vs phi , different eta,  depth=3 *****" <<endl;
1680   c3x5->Clear();
1681   c3x5->Divide(4, 4);
1682   c3x5->cd(1);
1683   int kcountHBnegativedirectionRecosignalD3 = 1;
1684   TH1F* h2CeffHBnegativedirectionRecosignalD3 = new TH1F("h2CeffHBnegativedirectionRecosignalD3", "", nphi, 0., 72.);
1685 
1686   for (int jeta = 0; jeta < njeta; jeta++) {
1687     // negativedirectionRecosignalD:
1688     if (jeta - 41 < 0) {
1689       //         for (int i=0;i<ndepth;i++) {
1690       // depth=3
1691       for (int i = 2; i < 3; i++) {
1692         TH1F* HBnegativedirectionRecosignalD3 = (TH1F*)h2CeffHBnegativedirectionRecosignalD3->Clone("twod1");
1693 
1694         float ccctest = 0;  // to avoid empty massive elements
1695         for (int jphi = 0; jphi < nphi; jphi++) {
1696           double ccc1 = recosignalvarianceHB[i][jeta][jphi];
1697           if (arecosignalHB[i][jeta][jphi] > 0.) {
1698             HBnegativedirectionRecosignalD3->Fill(jphi, ccc1);
1699             ccctest = 1.;  //HBnegativedirectionRecosignalD3->SetBinError(i,0.01);
1700           }
1701         }  // for jphi
1702         if (ccctest > 0.) {
1703           //cout<<"1616       kcountHBnegativedirectionRecosignalD3   =     "<<kcountHBnegativedirectionRecosignalD3  <<"   jeta-41=     "<< jeta-41 <<endl;
1704           c3x5->cd(kcountHBnegativedirectionRecosignalD3);
1705           HBnegativedirectionRecosignalD3->SetMarkerStyle(20);
1706           HBnegativedirectionRecosignalD3->SetMarkerSize(0.4);
1707           HBnegativedirectionRecosignalD3->GetYaxis()->SetLabelSize(0.04);
1708           HBnegativedirectionRecosignalD3->SetXTitle("HBnegativedirectionRecosignalD3 \b");
1709           HBnegativedirectionRecosignalD3->SetMarkerColor(2);
1710           HBnegativedirectionRecosignalD3->SetLineColor(0);
1711           gPad->SetGridy();
1712           gPad->SetGridx();
1713           //       gPad->SetLogy();
1714           if (kcountHBnegativedirectionRecosignalD3 == 1)
1715             HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-16; depth = 3 \b");
1716           if (kcountHBnegativedirectionRecosignalD3 == 2)
1717             HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-15; depth = 3 \b");
1718           if (kcountHBnegativedirectionRecosignalD3 == 3)
1719             HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-14; depth = 3 \b");
1720           if (kcountHBnegativedirectionRecosignalD3 == 4)
1721             HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-13; depth = 3 \b");
1722           if (kcountHBnegativedirectionRecosignalD3 == 5)
1723             HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-12; depth = 3 \b");
1724           if (kcountHBnegativedirectionRecosignalD3 == 6)
1725             HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-11; depth = 3 \b");
1726           if (kcountHBnegativedirectionRecosignalD3 == 7)
1727             HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-10; depth = 3 \b");
1728           if (kcountHBnegativedirectionRecosignalD3 == 8)
1729             HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-9 ; depth = 3 \b");
1730           if (kcountHBnegativedirectionRecosignalD3 == 9)
1731             HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-8 ; depth = 3 \b");
1732           if (kcountHBnegativedirectionRecosignalD3 == 10)
1733             HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-7 ; depth = 3 \b");
1734           if (kcountHBnegativedirectionRecosignalD3 == 11)
1735             HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-6 ; depth = 3 \b");
1736           if (kcountHBnegativedirectionRecosignalD3 == 12)
1737             HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-5 ; depth = 3 \b");
1738           if (kcountHBnegativedirectionRecosignalD3 == 13)
1739             HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-4 ; depth = 3 \b");
1740           if (kcountHBnegativedirectionRecosignalD3 == 14)
1741             HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-3 ; depth = 3 \b");
1742           if (kcountHBnegativedirectionRecosignalD3 == 15)
1743             HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-2 ; depth = 3 \b");
1744           if (kcountHBnegativedirectionRecosignalD3 == 16)
1745             HBnegativedirectionRecosignalD3->SetXTitle("D for HB- jeta =-1 ; depth = 3 \b");
1746           HBnegativedirectionRecosignalD3->Draw("Error");
1747           kcountHBnegativedirectionRecosignalD3++;
1748           if (kcountHBnegativedirectionRecosignalD3 > 16)
1749             break;  // 4x6 = 24
1750         }           //ccctest>0
1751 
1752       }  // for i
1753     }    //if(jeta-41 < 0)
1754   }      //for jeta
1755   /////////////////
1756   c3x5->Update();
1757   c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth3HB.png");
1758   c3x5->Clear();
1759   // clean-up
1760   if (h2CeffHBnegativedirectionRecosignalD3)
1761     delete h2CeffHBnegativedirectionRecosignalD3;
1762   //========================================================================================== 22217
1763   //======================================================================
1764   //======================================================================1D plot: D vs phi , different eta,  depth=4
1765   //cout<<"      1D plot: D vs phi , different eta,  depth=4 *****" <<endl;
1766   c3x5->Clear();
1767   c3x5->Divide(4, 4);
1768   c3x5->cd(1);
1769   int kcountHBnegativedirectionRecosignalD4 = 1;
1770   TH1F* h2CeffHBnegativedirectionRecosignalD4 = new TH1F("h2CeffHBnegativedirectionRecosignalD4", "", nphi, 0., 72.);
1771 
1772   for (int jeta = 0; jeta < njeta; jeta++) {
1773     // negativedirectionRecosignalD:
1774     if (jeta - 41 < 0) {
1775       //         for (int i=0;i<ndepth;i++) {
1776       // depth=4
1777       for (int i = 3; i < 4; i++) {
1778         TH1F* HBnegativedirectionRecosignalD4 = (TH1F*)h2CeffHBnegativedirectionRecosignalD4->Clone("twod1");
1779 
1780         float ccctest = 0;  // to avoid empty massive elements
1781         for (int jphi = 0; jphi < nphi; jphi++) {
1782           double ccc1 = recosignalvarianceHB[i][jeta][jphi];
1783           if (arecosignalHB[i][jeta][jphi] > 0.) {
1784             HBnegativedirectionRecosignalD4->Fill(jphi, ccc1);
1785             ccctest = 1.;  //HBnegativedirectionRecosignalD4->SetBinError(i,0.01);
1786           }
1787         }  // for jphi
1788         if (ccctest > 0.) {
1789           //cout<<"1717       kcountHBnegativedirectionRecosignalD4   =     "<<kcountHBnegativedirectionRecosignalD4  <<"   jeta-41=     "<< jeta-41 <<endl;
1790           c3x5->cd(kcountHBnegativedirectionRecosignalD4);
1791           HBnegativedirectionRecosignalD4->SetMarkerStyle(20);
1792           HBnegativedirectionRecosignalD4->SetMarkerSize(0.4);
1793           HBnegativedirectionRecosignalD4->GetYaxis()->SetLabelSize(0.04);
1794           HBnegativedirectionRecosignalD4->SetXTitle("HBnegativedirectionRecosignalD4 \b");
1795           HBnegativedirectionRecosignalD4->SetMarkerColor(2);
1796           HBnegativedirectionRecosignalD4->SetLineColor(0);
1797           gPad->SetGridy();
1798           gPad->SetGridx();
1799           //       gPad->SetLogy();
1800           if (kcountHBnegativedirectionRecosignalD4 == 1)
1801             HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-16; depth = 4 \b");
1802           if (kcountHBnegativedirectionRecosignalD4 == 2)
1803             HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-15; depth = 4 \b");
1804           if (kcountHBnegativedirectionRecosignalD4 == 3)
1805             HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-14; depth = 4 \b");
1806           if (kcountHBnegativedirectionRecosignalD4 == 4)
1807             HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-13; depth = 4 \b");
1808           if (kcountHBnegativedirectionRecosignalD4 == 5)
1809             HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-12; depth = 4 \b");
1810           if (kcountHBnegativedirectionRecosignalD4 == 6)
1811             HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-11; depth = 4 \b");
1812           if (kcountHBnegativedirectionRecosignalD4 == 7)
1813             HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-10; depth = 4 \b");
1814           if (kcountHBnegativedirectionRecosignalD4 == 8)
1815             HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-9 ; depth = 4 \b");
1816           if (kcountHBnegativedirectionRecosignalD4 == 9)
1817             HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-8 ; depth = 4 \b");
1818           if (kcountHBnegativedirectionRecosignalD4 == 10)
1819             HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-7 ; depth = 4 \b");
1820           if (kcountHBnegativedirectionRecosignalD4 == 11)
1821             HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-6 ; depth = 4 \b");
1822           if (kcountHBnegativedirectionRecosignalD4 == 12)
1823             HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-5 ; depth = 4 \b");
1824           if (kcountHBnegativedirectionRecosignalD4 == 13)
1825             HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-4 ; depth = 4 \b");
1826           if (kcountHBnegativedirectionRecosignalD4 == 14)
1827             HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-3 ; depth = 4 \b");
1828           if (kcountHBnegativedirectionRecosignalD4 == 15)
1829             HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-2 ; depth = 4 \b");
1830           if (kcountHBnegativedirectionRecosignalD4 == 16)
1831             HBnegativedirectionRecosignalD4->SetXTitle("D for HB- jeta =-1 ; depth = 4 \b");
1832           HBnegativedirectionRecosignalD4->Draw("Error");
1833           kcountHBnegativedirectionRecosignalD4++;
1834           if (kcountHBnegativedirectionRecosignalD4 > 16)
1835             break;  // 4x6 = 24
1836         }           //ccctest>0
1837 
1838       }  // for i
1839     }    //if(jeta-41 < 0)
1840   }      //for jeta
1841   /////////////////
1842   c3x5->Update();
1843   c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth4HB.png");
1844   c3x5->Clear();
1845   // clean-up
1846   if (h2CeffHBnegativedirectionRecosignalD4)
1847     delete h2CeffHBnegativedirectionRecosignalD4;
1848 
1849   //=====================================================================       END of Recosignal HB for phi-symmetry
1850   //=====================================================================       END of Recosignal HB for phi-symmetry
1851   //=====================================================================       END of Recosignal HB for phi-symmetry
1852 
1853   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Recosignal HE
1854   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Recosignal HE
1855   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Recosignal HE
1856   //  int k_max[5]={0,4,7,4,4}; // maximum depth for each subdet
1857   //ndepth = k_max[3];
1858   ndepth = 7;
1859   //  const int ndepth = 7;
1860   double arecosignalhe[ndepth][njeta][njphi];
1861   double recosignalvariancehe[ndepth][njeta][njphi];
1862   //                                   RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR:   Recosignal HE
1863   TH2F* recSignalEnergy1HE1 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy1_HE1");
1864   TH2F* recSignalEnergy0HE1 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HE1");
1865   TH2F* recSignalEnergyHE1 = (TH2F*)recSignalEnergy1HE1->Clone("recSignalEnergyHE1");
1866   recSignalEnergyHE1->Divide(recSignalEnergy1HE1, recSignalEnergy0HE1, 1, 1, "B");
1867   TH2F* recSignalEnergy1HE2 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy1_HE2");
1868   TH2F* recSignalEnergy0HE2 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HE2");
1869   TH2F* recSignalEnergyHE2 = (TH2F*)recSignalEnergy1HE2->Clone("recSignalEnergyHE2");
1870   recSignalEnergyHE2->Divide(recSignalEnergy1HE2, recSignalEnergy0HE2, 1, 1, "B");
1871   TH2F* recSignalEnergy1HE3 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy1_HE3");
1872   TH2F* recSignalEnergy0HE3 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HE3");
1873   TH2F* recSignalEnergyHE3 = (TH2F*)recSignalEnergy1HE3->Clone("recSignalEnergyHE3");
1874   recSignalEnergyHE3->Divide(recSignalEnergy1HE3, recSignalEnergy0HE3, 1, 1, "B");
1875   TH2F* recSignalEnergy1HE4 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy1_HE4");
1876   TH2F* recSignalEnergy0HE4 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HE4");
1877   TH2F* recSignalEnergyHE4 = (TH2F*)recSignalEnergy1HE4->Clone("recSignalEnergyHE4");
1878   recSignalEnergyHE4->Divide(recSignalEnergy1HE4, recSignalEnergy0HE4, 1, 1, "B");
1879   TH2F* recSignalEnergy1HE5 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy1_HE5");
1880   TH2F* recSignalEnergy0HE5 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HE5");
1881   TH2F* recSignalEnergyHE5 = (TH2F*)recSignalEnergy1HE5->Clone("recSignalEnergyHE5");
1882   recSignalEnergyHE5->Divide(recSignalEnergy1HE5, recSignalEnergy0HE5, 1, 1, "B");
1883   TH2F* recSignalEnergy1HE6 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy1_HE6");
1884   TH2F* recSignalEnergy0HE6 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HE6");
1885   TH2F* recSignalEnergyHE6 = (TH2F*)recSignalEnergy1HE6->Clone("recSignalEnergyHE6");
1886   recSignalEnergyHE6->Divide(recSignalEnergy1HE6, recSignalEnergy0HE6, 1, 1, "B");
1887   TH2F* recSignalEnergy1HE7 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy1_HE7");
1888   TH2F* recSignalEnergy0HE7 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HE7");
1889   TH2F* recSignalEnergyHE7 = (TH2F*)recSignalEnergy1HE7->Clone("recSignalEnergyHE7");
1890   recSignalEnergyHE7->Divide(recSignalEnergy1HE7, recSignalEnergy0HE7, 1, 1, "B");
1891   for (int jeta = 0; jeta < njeta; jeta++) {
1892     //====================================================================== PHI normalization & put R into massive arecosignalhe
1893     //preparation for PHI normalization:
1894     double sumrecosignalHE0 = 0;
1895     int nsumrecosignalHE0 = 0;
1896     double sumrecosignalHE1 = 0;
1897     int nsumrecosignalHE1 = 0;
1898     double sumrecosignalHE2 = 0;
1899     int nsumrecosignalHE2 = 0;
1900     double sumrecosignalHE3 = 0;
1901     int nsumrecosignalHE3 = 0;
1902     double sumrecosignalHE4 = 0;
1903     int nsumrecosignalHE4 = 0;
1904     double sumrecosignalHE5 = 0;
1905     int nsumrecosignalHE5 = 0;
1906     double sumrecosignalHE6 = 0;
1907     int nsumrecosignalHE6 = 0;
1908     for (int jphi = 0; jphi < njphi; jphi++) {
1909       arecosignalhe[0][jeta][jphi] = recSignalEnergyHE1->GetBinContent(jeta + 1, jphi + 1);
1910       arecosignalhe[1][jeta][jphi] = recSignalEnergyHE2->GetBinContent(jeta + 1, jphi + 1);
1911       arecosignalhe[2][jeta][jphi] = recSignalEnergyHE3->GetBinContent(jeta + 1, jphi + 1);
1912       arecosignalhe[3][jeta][jphi] = recSignalEnergyHE4->GetBinContent(jeta + 1, jphi + 1);
1913       arecosignalhe[4][jeta][jphi] = recSignalEnergyHE5->GetBinContent(jeta + 1, jphi + 1);
1914       arecosignalhe[5][jeta][jphi] = recSignalEnergyHE6->GetBinContent(jeta + 1, jphi + 1);
1915       arecosignalhe[6][jeta][jphi] = recSignalEnergyHE7->GetBinContent(jeta + 1, jphi + 1);
1916       if (arecosignalhe[0][jeta][jphi] > 0.) {
1917         sumrecosignalHE0 += arecosignalhe[0][jeta][jphi];
1918         ++nsumrecosignalHE0;
1919       }
1920       if (arecosignalhe[1][jeta][jphi] > 0.) {
1921         sumrecosignalHE1 += arecosignalhe[1][jeta][jphi];
1922         ++nsumrecosignalHE1;
1923       }
1924       if (arecosignalhe[2][jeta][jphi] > 0.) {
1925         sumrecosignalHE2 += arecosignalhe[2][jeta][jphi];
1926         ++nsumrecosignalHE2;
1927       }
1928       if (arecosignalhe[3][jeta][jphi] > 0.) {
1929         sumrecosignalHE3 += arecosignalhe[3][jeta][jphi];
1930         ++nsumrecosignalHE3;
1931       }
1932       if (arecosignalhe[4][jeta][jphi] > 0.) {
1933         sumrecosignalHE4 += arecosignalhe[4][jeta][jphi];
1934         ++nsumrecosignalHE4;
1935       }
1936       if (arecosignalhe[5][jeta][jphi] > 0.) {
1937         sumrecosignalHE5 += arecosignalhe[5][jeta][jphi];
1938         ++nsumrecosignalHE5;
1939       }
1940       if (arecosignalhe[6][jeta][jphi] > 0.) {
1941         sumrecosignalHE6 += arecosignalhe[6][jeta][jphi];
1942         ++nsumrecosignalHE6;
1943       }
1944     }  // phi
1945     // PHI normalization:
1946     for (int jphi = 0; jphi < njphi; jphi++) {
1947       if (arecosignalhe[0][jeta][jphi] > 0.)
1948         arecosignalhe[0][jeta][jphi] /= (sumrecosignalHE0 / nsumrecosignalHE0);
1949       if (arecosignalhe[1][jeta][jphi] > 0.)
1950         arecosignalhe[1][jeta][jphi] /= (sumrecosignalHE1 / nsumrecosignalHE1);
1951       if (arecosignalhe[2][jeta][jphi] > 0.)
1952         arecosignalhe[2][jeta][jphi] /= (sumrecosignalHE2 / nsumrecosignalHE2);
1953       if (arecosignalhe[3][jeta][jphi] > 0.)
1954         arecosignalhe[3][jeta][jphi] /= (sumrecosignalHE3 / nsumrecosignalHE3);
1955       if (arecosignalhe[4][jeta][jphi] > 0.)
1956         arecosignalhe[4][jeta][jphi] /= (sumrecosignalHE4 / nsumrecosignalHE4);
1957       if (arecosignalhe[5][jeta][jphi] > 0.)
1958         arecosignalhe[5][jeta][jphi] /= (sumrecosignalHE5 / nsumrecosignalHE5);
1959       if (arecosignalhe[6][jeta][jphi] > 0.)
1960         arecosignalhe[6][jeta][jphi] /= (sumrecosignalHE6 / nsumrecosignalHE6);
1961     }  // phi
1962   }    //eta
1963   //------------------------  2D-eta/phi-plot: R, averaged over depthes
1964   //======================================================================
1965   //======================================================================
1966   //cout<<"      R2D-eta/phi-plot: R, averaged over depthes *****" <<endl;
1967   c2x1->Clear();
1968   /////////////////
1969   c2x1->Divide(2, 1);
1970   c2x1->cd(1);
1971   TH2F* GefzRrecosignalHE42D = new TH2F("GefzRrecosignalHE42D", "", neta, -41., 41., nphi, 0., 72.);
1972   TH2F* GefzRrecosignalHE42D0 = new TH2F("GefzRrecosignalHE42D0", "", neta, -41., 41., nphi, 0., 72.);
1973   TH2F* GefzRrecosignalHE42DF = (TH2F*)GefzRrecosignalHE42D0->Clone("GefzRrecosignalHE42DF");
1974   for (int i = 0; i < ndepth; i++) {
1975     for (int jeta = 0; jeta < neta; jeta++) {
1976       for (int jphi = 0; jphi < nphi; jphi++) {
1977         double ccc1 = arecosignalhe[i][jeta][jphi];
1978         int k2plot = jeta - 41;
1979         int kkk = k2plot;  //if(k2plot >0 ) kkk=k2plot+1; //-41 +41 !=0
1980         if (ccc1 != 0.) {
1981           GefzRrecosignalHE42D->Fill(kkk, jphi, ccc1);
1982           GefzRrecosignalHE42D0->Fill(kkk, jphi, 1.);
1983         }
1984       }
1985     }
1986   }
1987   GefzRrecosignalHE42DF->Divide(GefzRrecosignalHE42D, GefzRrecosignalHE42D0, 1, 1, "B");  // average A
1988   gPad->SetGridy();
1989   gPad->SetGridx();  //      gPad->SetLogz();
1990   GefzRrecosignalHE42DF->SetXTitle("<R>_depth       #eta  \b");
1991   GefzRrecosignalHE42DF->SetYTitle("      #phi \b");
1992   GefzRrecosignalHE42DF->Draw("COLZ");
1993 
1994   c2x1->cd(2);
1995   TH1F* energyhitSignal_HE = (TH1F*)dir->FindObjectAny("h_energyhitSignal_HE");
1996   energyhitSignal_HE->SetMarkerStyle(20);
1997   energyhitSignal_HE->SetMarkerSize(0.4);
1998   energyhitSignal_HE->GetYaxis()->SetLabelSize(0.04);
1999   energyhitSignal_HE->SetXTitle("energyhitSignal_HE \b");
2000   energyhitSignal_HE->SetMarkerColor(2);
2001   energyhitSignal_HE->SetLineColor(0);
2002   gPad->SetGridy();
2003   gPad->SetGridx();
2004   energyhitSignal_HE->Draw("Error");
2005 
2006   /////////////////
2007   c2x1->Update();
2008   c2x1->Print("RrecosignalGeneralD2PhiSymmetryHE.png");
2009   c2x1->Clear();
2010   // clean-up
2011   if (GefzRrecosignalHE42D)
2012     delete GefzRrecosignalHE42D;
2013   if (GefzRrecosignalHE42D0)
2014     delete GefzRrecosignalHE42D0;
2015   if (GefzRrecosignalHE42DF)
2016     delete GefzRrecosignalHE42DF;
2017   //====================================================================== 1D plot: R vs phi , averaged over depthes & eta
2018   //======================================================================
2019   //cout<<"      1D plot: R vs phi , averaged over depthes & eta *****" <<endl;
2020   c1x1->Clear();
2021   /////////////////
2022   c1x1->Divide(1, 1);
2023   c1x1->cd(1);
2024   TH1F* GefzRrecosignalHE41D = new TH1F("GefzRrecosignalHE41D", "", nphi, 0., 72.);
2025   TH1F* GefzRrecosignalHE41D0 = new TH1F("GefzRrecosignalHE41D0", "", nphi, 0., 72.);
2026   TH1F* GefzRrecosignalHE41DF = (TH1F*)GefzRrecosignalHE41D0->Clone("GefzRrecosignalHE41DF");
2027   for (int jphi = 0; jphi < nphi; jphi++) {
2028     for (int jeta = 0; jeta < neta; jeta++) {
2029       for (int i = 0; i < ndepth; i++) {
2030         double ccc1 = arecosignalhe[i][jeta][jphi];
2031         if (ccc1 != 0.) {
2032           GefzRrecosignalHE41D->Fill(jphi, ccc1);
2033           GefzRrecosignalHE41D0->Fill(jphi, 1.);
2034         }
2035       }
2036     }
2037   }
2038   GefzRrecosignalHE41DF->Divide(
2039       GefzRrecosignalHE41D, GefzRrecosignalHE41D0, 1, 1, "B");  // R averaged over depthes & eta
2040   GefzRrecosignalHE41D0->Sumw2();
2041   //    for (int jphi=1;jphi<73;jphi++) {GefzRrecosignalHE41DF->SetBinError(jphi,0.01);}
2042   gPad->SetGridy();
2043   gPad->SetGridx();  //      gPad->SetLogz();
2044   GefzRrecosignalHE41DF->SetMarkerStyle(20);
2045   GefzRrecosignalHE41DF->SetMarkerSize(1.4);
2046   GefzRrecosignalHE41DF->GetZaxis()->SetLabelSize(0.08);
2047   GefzRrecosignalHE41DF->SetXTitle("#phi  \b");
2048   GefzRrecosignalHE41DF->SetYTitle("  <R> \b");
2049   GefzRrecosignalHE41DF->SetZTitle("<R>_PHI  - AllDepthes \b");
2050   GefzRrecosignalHE41DF->SetMarkerColor(4);
2051   GefzRrecosignalHE41DF->SetLineColor(
2052       4);  //  GefzRrecosignalHE41DF->SetMinimum(0.8);     //      GefzRrecosignalHE41DF->SetMaximum(1.000);
2053   GefzRrecosignalHE41DF->Draw("Error");
2054   /////////////////
2055   c1x1->Update();
2056   c1x1->Print("RrecosignalGeneralD1PhiSymmetryHE.png");
2057   c1x1->Clear();
2058   // clean-up
2059   if (GefzRrecosignalHE41D)
2060     delete GefzRrecosignalHE41D;
2061   if (GefzRrecosignalHE41D0)
2062     delete GefzRrecosignalHE41D0;
2063   if (GefzRrecosignalHE41DF)
2064     delete GefzRrecosignalHE41DF;
2065 
2066   //========================================================================================== 4
2067   //======================================================================
2068   //======================================================================1D plot: R vs phi , different eta,  depth=1
2069   //cout<<"      1D plot: R vs phi , different eta,  depth=1 *****" <<endl;
2070   c3x5->Clear();
2071   /////////////////
2072   c3x5->Divide(3, 5);
2073   c3x5->cd(1);
2074   int kcountHEpositivedirectionRecosignal1 = 1;
2075   TH1F* h2CeffHEpositivedirectionRecosignal1 = new TH1F("h2CeffHEpositivedirectionRecosignal1", "", nphi, 0., 72.);
2076   for (int jeta = 0; jeta < njeta; jeta++) {
2077     // positivedirectionRecosignal:
2078     if (jeta - 41 >= 0) {
2079       //         for (int i=0;i<ndepth;i++) {
2080       // depth=1
2081       for (int i = 0; i < 1; i++) {
2082         TH1F* HEpositivedirectionRecosignal1 = (TH1F*)h2CeffHEpositivedirectionRecosignal1->Clone("twod1");
2083         float ccctest = 0;  // to avoid empty massive elements
2084         for (int jphi = 0; jphi < nphi; jphi++) {
2085           double ccc1 = arecosignalhe[i][jeta][jphi];
2086           if (ccc1 != 0.) {
2087             HEpositivedirectionRecosignal1->Fill(jphi, ccc1);
2088             ccctest = 1.;  //HEpositivedirectionRecosignal1->SetBinError(i,0.01);
2089           }
2090         }  // for jphi
2091         if (ccctest > 0.) {
2092           //      cout<<"444        kcountHEpositivedirectionRecosignal1   =     "<<kcountHEpositivedirectionRecosignal1  <<"   jeta-41=     "<< jeta-41 <<endl;
2093           c3x5->cd(kcountHEpositivedirectionRecosignal1);
2094           HEpositivedirectionRecosignal1->SetMarkerStyle(20);
2095           HEpositivedirectionRecosignal1->SetMarkerSize(0.4);
2096           HEpositivedirectionRecosignal1->GetYaxis()->SetLabelSize(0.04);
2097           HEpositivedirectionRecosignal1->SetXTitle("HEpositivedirectionRecosignal1 \b");
2098           HEpositivedirectionRecosignal1->SetMarkerColor(2);
2099           HEpositivedirectionRecosignal1->SetLineColor(0);
2100           gPad->SetGridy();
2101           gPad->SetGridx();
2102           //       gPad->SetLogy();
2103           if (kcountHEpositivedirectionRecosignal1 == 1)
2104             HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 17; depth = 1 \b");
2105           if (kcountHEpositivedirectionRecosignal1 == 2)
2106             HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 18; depth = 1 \b");
2107           if (kcountHEpositivedirectionRecosignal1 == 3)
2108             HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 19; depth = 1 \b");
2109           if (kcountHEpositivedirectionRecosignal1 == 4)
2110             HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 20; depth = 1 \b");
2111           if (kcountHEpositivedirectionRecosignal1 == 5)
2112             HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 21; depth = 1 \b");
2113           if (kcountHEpositivedirectionRecosignal1 == 6)
2114             HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 22; depth = 1 \b");
2115           if (kcountHEpositivedirectionRecosignal1 == 7)
2116             HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 23; depth = 1 \b");
2117           if (kcountHEpositivedirectionRecosignal1 == 8)
2118             HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 24; depth = 1 \b");
2119           if (kcountHEpositivedirectionRecosignal1 == 9)
2120             HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 25; depth = 1 \b");
2121           if (kcountHEpositivedirectionRecosignal1 == 10)
2122             HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 26; depth = 1 \b");
2123           if (kcountHEpositivedirectionRecosignal1 == 11)
2124             HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 27; depth = 1 \b");
2125           if (kcountHEpositivedirectionRecosignal1 == 12)
2126             HEpositivedirectionRecosignal1->SetXTitle("R for HE+ jeta = 28; depth = 1 \b");
2127           HEpositivedirectionRecosignal1->Draw("Error");
2128           kcountHEpositivedirectionRecosignal1++;
2129           if (kcountHEpositivedirectionRecosignal1 > 12)
2130             break;  // 4x6 = 24
2131         }           //ccctest>0
2132 
2133       }  // for i
2134     }    //if(jeta-41 >= 0)
2135   }      //for jeta
2136   /////////////////
2137   c3x5->Update();
2138   c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth1HE.png");
2139   c3x5->Clear();
2140   // clean-up
2141   if (h2CeffHEpositivedirectionRecosignal1)
2142     delete h2CeffHEpositivedirectionRecosignal1;
2143 
2144   //========================================================================================== 5
2145   //======================================================================
2146   //======================================================================1D plot: R vs phi , different eta,  depth=2
2147   //  cout<<"      1D plot: R vs phi , different eta,  depth=2 *****" <<endl;
2148   c3x5->Clear();
2149   /////////////////
2150   c3x5->Divide(3, 5);
2151   c3x5->cd(1);
2152   int kcountHEpositivedirectionRecosignal2 = 1;
2153   TH1F* h2CeffHEpositivedirectionRecosignal2 = new TH1F("h2CeffHEpositivedirectionRecosignal2", "", nphi, 0., 72.);
2154   for (int jeta = 0; jeta < njeta; jeta++) {
2155     // positivedirectionRecosignal:
2156     if (jeta - 41 >= 0) {
2157       //         for (int i=0;i<ndepth;i++) {
2158       // depth=2
2159       for (int i = 1; i < 2; i++) {
2160         TH1F* HEpositivedirectionRecosignal2 = (TH1F*)h2CeffHEpositivedirectionRecosignal2->Clone("twod1");
2161         float ccctest = 0;  // to avoid empty massive elements
2162         for (int jphi = 0; jphi < nphi; jphi++) {
2163           double ccc1 = arecosignalhe[i][jeta][jphi];
2164           if (ccc1 != 0.) {
2165             HEpositivedirectionRecosignal2->Fill(jphi, ccc1);
2166             ccctest = 1.;  //HEpositivedirectionRecosignal2->SetBinError(i,0.01);
2167           }
2168         }  // for jphi
2169         if (ccctest > 0.) {
2170           //cout<<"555        kcountHEpositivedirectionRecosignal2   =     "<<kcountHEpositivedirectionRecosignal2  <<"   jeta-41=     "<< jeta-41 <<endl;
2171           c3x5->cd(kcountHEpositivedirectionRecosignal2);
2172           HEpositivedirectionRecosignal2->SetMarkerStyle(20);
2173           HEpositivedirectionRecosignal2->SetMarkerSize(0.4);
2174           HEpositivedirectionRecosignal2->GetYaxis()->SetLabelSize(0.04);
2175           HEpositivedirectionRecosignal2->SetXTitle("HEpositivedirectionRecosignal2 \b");
2176           HEpositivedirectionRecosignal2->SetMarkerColor(2);
2177           HEpositivedirectionRecosignal2->SetLineColor(0);
2178           gPad->SetGridy();
2179           gPad->SetGridx();
2180           //       gPad->SetLogy();
2181           if (kcountHEpositivedirectionRecosignal2 == 1)
2182             HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 16; depth = 2 \b");
2183           if (kcountHEpositivedirectionRecosignal2 == 2)
2184             HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 17; depth = 2 \b");
2185           if (kcountHEpositivedirectionRecosignal2 == 3)
2186             HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 18; depth = 2 \b");
2187           if (kcountHEpositivedirectionRecosignal2 == 4)
2188             HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 19; depth = 2 \b");
2189           if (kcountHEpositivedirectionRecosignal2 == 5)
2190             HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 20; depth = 2 \b");
2191           if (kcountHEpositivedirectionRecosignal2 == 6)
2192             HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 21; depth = 2 \b");
2193           if (kcountHEpositivedirectionRecosignal2 == 7)
2194             HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 22; depth = 2 \b");
2195           if (kcountHEpositivedirectionRecosignal2 == 8)
2196             HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 23; depth = 2 \b");
2197           if (kcountHEpositivedirectionRecosignal2 == 9)
2198             HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 24; depth = 2 \b");
2199           if (kcountHEpositivedirectionRecosignal2 == 10)
2200             HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 25; depth = 2 \b");
2201           if (kcountHEpositivedirectionRecosignal2 == 11)
2202             HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 26; depth = 2 \b");
2203           if (kcountHEpositivedirectionRecosignal2 == 12)
2204             HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 27; depth = 2 \b");
2205           if (kcountHEpositivedirectionRecosignal2 == 13)
2206             HEpositivedirectionRecosignal2->SetXTitle("R for HE+ jeta = 28; depth = 2 \b");
2207           HEpositivedirectionRecosignal2->Draw("Error");
2208           kcountHEpositivedirectionRecosignal2++;
2209           if (kcountHEpositivedirectionRecosignal2 > 13)
2210             break;  // 4x6 = 24
2211         }           //ccctest>0
2212 
2213       }  // for i
2214     }    //if(jeta-41 >= 0)
2215   }      //for jeta
2216   /////////////////
2217   c3x5->Update();
2218   c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth2HE.png");
2219   c3x5->Clear();
2220   // clean-up
2221   if (h2CeffHEpositivedirectionRecosignal2)
2222     delete h2CeffHEpositivedirectionRecosignal2;
2223   //========================================================================================== 6
2224   //======================================================================
2225   //======================================================================1D plot: R vs phi , different eta,  depth=3
2226   //cout<<"      1D plot: R vs phi , different eta,  depth=3 *****" <<endl;
2227   c3x5->Clear();
2228   /////////////////
2229   c3x5->Divide(3, 5);
2230   c3x5->cd(1);
2231   int kcountHEpositivedirectionRecosignal3 = 1;
2232   TH1F* h2CeffHEpositivedirectionRecosignal3 = new TH1F("h2CeffHEpositivedirectionRecosignal3", "", nphi, 0., 72.);
2233   for (int jeta = 0; jeta < njeta; jeta++) {
2234     // positivedirectionRecosignal:
2235     if (jeta - 41 >= 0) {
2236       //         for (int i=0;i<ndepth;i++) {
2237       // depth=3
2238       for (int i = 2; i < 3; i++) {
2239         TH1F* HEpositivedirectionRecosignal3 = (TH1F*)h2CeffHEpositivedirectionRecosignal3->Clone("twod1");
2240         float ccctest = 0;  // to avoid empty massive elements
2241         for (int jphi = 0; jphi < nphi; jphi++) {
2242           double ccc1 = arecosignalhe[i][jeta][jphi];
2243           if (ccc1 != 0.) {
2244             HEpositivedirectionRecosignal3->Fill(jphi, ccc1);
2245             ccctest = 1.;  //HEpositivedirectionRecosignal3->SetBinError(i,0.01);
2246           }
2247         }  // for jphi
2248         if (ccctest > 0.) {
2249           //cout<<"666        kcountHEpositivedirectionRecosignal3   =     "<<kcountHEpositivedirectionRecosignal3  <<"   jeta-41=     "<< jeta-41 <<endl;
2250           c3x5->cd(kcountHEpositivedirectionRecosignal3);
2251           HEpositivedirectionRecosignal3->SetMarkerStyle(20);
2252           HEpositivedirectionRecosignal3->SetMarkerSize(0.4);
2253           HEpositivedirectionRecosignal3->GetYaxis()->SetLabelSize(0.04);
2254           HEpositivedirectionRecosignal3->SetXTitle("HEpositivedirectionRecosignal3 \b");
2255           HEpositivedirectionRecosignal3->SetMarkerColor(2);
2256           HEpositivedirectionRecosignal3->SetLineColor(0);
2257           gPad->SetGridy();
2258           gPad->SetGridx();
2259           //       gPad->SetLogy();
2260           if (kcountHEpositivedirectionRecosignal3 == 1)
2261             HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 16; depth = 3 \b");
2262           if (kcountHEpositivedirectionRecosignal3 == 2)
2263             HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 17; depth = 3 \b");
2264           if (kcountHEpositivedirectionRecosignal3 == 3)
2265             HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 18; depth = 3 \b");
2266           if (kcountHEpositivedirectionRecosignal3 == 4)
2267             HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 19; depth = 3 \b");
2268           if (kcountHEpositivedirectionRecosignal3 == 5)
2269             HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 20; depth = 3 \b");
2270           if (kcountHEpositivedirectionRecosignal3 == 6)
2271             HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 21; depth = 3 \b");
2272           if (kcountHEpositivedirectionRecosignal3 == 7)
2273             HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 22; depth = 3 \b");
2274           if (kcountHEpositivedirectionRecosignal3 == 8)
2275             HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 23; depth = 3 \b");
2276           if (kcountHEpositivedirectionRecosignal3 == 9)
2277             HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 24; depth = 3 \b");
2278           if (kcountHEpositivedirectionRecosignal3 == 10)
2279             HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 25; depth = 3 \b");
2280           if (kcountHEpositivedirectionRecosignal3 == 11)
2281             HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 26; depth = 3 \b");
2282           if (kcountHEpositivedirectionRecosignal3 == 12)
2283             HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 27; depth = 3 \b");
2284           if (kcountHEpositivedirectionRecosignal3 == 13)
2285             HEpositivedirectionRecosignal3->SetXTitle("R for HE+ jeta = 28; depth = 3 \b");
2286           HEpositivedirectionRecosignal3->Draw("Error");
2287           kcountHEpositivedirectionRecosignal3++;
2288           if (kcountHEpositivedirectionRecosignal3 > 13)
2289             break;  // 4x6 = 24
2290         }           //ccctest>0
2291 
2292       }  // for i
2293     }    //if(jeta-41 >= 0)
2294   }      //for jeta
2295   /////////////////
2296   c3x5->Update();
2297   c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth3HE.png");
2298   c3x5->Clear();
2299   // clean-up
2300   if (h2CeffHEpositivedirectionRecosignal3)
2301     delete h2CeffHEpositivedirectionRecosignal3;
2302   //========================================================================================== 7
2303   //======================================================================
2304   //======================================================================1D plot: R vs phi , different eta,  depth=4
2305   //cout<<"      1D plot: R vs phi , different eta,  depth=4 *****" <<endl;
2306   c3x5->Clear();
2307   /////////////////
2308   c3x5->Divide(3, 5);
2309   c3x5->cd(1);
2310   int kcountHEpositivedirectionRecosignal4 = 1;
2311   TH1F* h2CeffHEpositivedirectionRecosignal4 = new TH1F("h2CeffHEpositivedirectionRecosignal4", "", nphi, 0., 72.);
2312 
2313   for (int jeta = 0; jeta < njeta; jeta++) {
2314     // positivedirectionRecosignal:
2315     if (jeta - 41 >= 0) {
2316       //         for (int i=0;i<ndepth;i++) {
2317       // depth=4
2318       for (int i = 3; i < 4; i++) {
2319         TH1F* HEpositivedirectionRecosignal4 = (TH1F*)h2CeffHEpositivedirectionRecosignal4->Clone("twod1");
2320 
2321         float ccctest = 0;  // to avoid empty massive elements
2322         for (int jphi = 0; jphi < nphi; jphi++) {
2323           double ccc1 = arecosignalhe[i][jeta][jphi];
2324           if (ccc1 != 0.) {
2325             HEpositivedirectionRecosignal4->Fill(jphi, ccc1);
2326             ccctest = 1.;  //HEpositivedirectionRecosignal4->SetBinError(i,0.01);
2327           }
2328         }  // for jphi
2329         if (ccctest > 0.) {
2330           //cout<<"777        kcountHEpositivedirectionRecosignal4   =     "<<kcountHEpositivedirectionRecosignal4  <<"   jeta-41=     "<< jeta-41 <<endl;
2331           c3x5->cd(kcountHEpositivedirectionRecosignal4);
2332           HEpositivedirectionRecosignal4->SetMarkerStyle(20);
2333           HEpositivedirectionRecosignal4->SetMarkerSize(0.4);
2334           HEpositivedirectionRecosignal4->GetYaxis()->SetLabelSize(0.04);
2335           HEpositivedirectionRecosignal4->SetXTitle("HEpositivedirectionRecosignal4 \b");
2336           HEpositivedirectionRecosignal4->SetMarkerColor(2);
2337           HEpositivedirectionRecosignal4->SetLineColor(0);
2338           gPad->SetGridy();
2339           gPad->SetGridx();
2340           //       gPad->SetLogy();
2341           if (kcountHEpositivedirectionRecosignal4 == 1)
2342             HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 15; depth = 4 \b");
2343           if (kcountHEpositivedirectionRecosignal4 == 2)
2344             HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 17; depth = 4 \b");
2345           if (kcountHEpositivedirectionRecosignal4 == 3)
2346             HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 18; depth = 4 \b");
2347           if (kcountHEpositivedirectionRecosignal4 == 4)
2348             HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 19; depth = 4 \b");
2349           if (kcountHEpositivedirectionRecosignal4 == 5)
2350             HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 20; depth = 4 \b");
2351           if (kcountHEpositivedirectionRecosignal4 == 6)
2352             HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 21; depth = 4 \b");
2353           if (kcountHEpositivedirectionRecosignal4 == 7)
2354             HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 22; depth = 4 \b");
2355           if (kcountHEpositivedirectionRecosignal4 == 8)
2356             HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 23; depth = 4 \b");
2357           if (kcountHEpositivedirectionRecosignal4 == 9)
2358             HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 24; depth = 4 \b");
2359           if (kcountHEpositivedirectionRecosignal4 == 10)
2360             HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 25; depth = 4 \b");
2361           if (kcountHEpositivedirectionRecosignal4 == 11)
2362             HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 26; depth = 4 \b");
2363           if (kcountHEpositivedirectionRecosignal4 == 12)
2364             HEpositivedirectionRecosignal4->SetXTitle("R for HE+ jeta = 27; depth = 4 \b");
2365           HEpositivedirectionRecosignal4->Draw("Error");
2366           kcountHEpositivedirectionRecosignal4++;
2367           if (kcountHEpositivedirectionRecosignal4 > 12)
2368             break;  // 4x6 = 24
2369         }           //ccctest>0
2370 
2371       }  // for i
2372     }    //if(jeta-41 >= 0)
2373   }      //for jeta
2374   /////////////////
2375   c3x5->Update();
2376   c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth4HE.png");
2377   c3x5->Clear();
2378   // clean-up
2379   if (h2CeffHEpositivedirectionRecosignal4)
2380     delete h2CeffHEpositivedirectionRecosignal4;
2381   //========================================================================================== 8
2382   //======================================================================
2383   //======================================================================1D plot: R vs phi , different eta,  depth=5
2384   //cout<<"      1D plot: R vs phi , different eta,  depth=5 *****" <<endl;
2385   c3x5->Clear();
2386   /////////////////
2387   c3x5->Divide(3, 5);
2388   c3x5->cd(1);
2389   int kcountHEpositivedirectionRecosignal5 = 1;
2390   TH1F* h2CeffHEpositivedirectionRecosignal5 = new TH1F("h2CeffHEpositivedirectionRecosignal5", "", nphi, 0., 72.);
2391 
2392   for (int jeta = 0; jeta < njeta; jeta++) {
2393     // positivedirectionRecosignal:
2394     if (jeta - 41 >= 0) {
2395       //         for (int i=0;i<ndepth;i++) {
2396       // depth=5
2397       for (int i = 4; i < 5; i++) {
2398         TH1F* HEpositivedirectionRecosignal5 = (TH1F*)h2CeffHEpositivedirectionRecosignal5->Clone("twod1");
2399 
2400         float ccctest = 0;  // to avoid empty massive elements
2401         for (int jphi = 0; jphi < nphi; jphi++) {
2402           //           cout<<"888  initial      kcountHEpositivedirectionRecosignal5   =     "<<kcountHEpositivedirectionRecosignal5  <<"   jeta-41=     "<< jeta-41 <<"   jphi=     "<< jphi <<"   arecosignalhe[i][jeta][jphi]=     "<< arecosignalhe[i][jeta][jphi] <<"  depth=     "<< i <<endl;
2403 
2404           double ccc1 = arecosignalhe[i][jeta][jphi];
2405           if (ccc1 != 0.) {
2406             HEpositivedirectionRecosignal5->Fill(jphi, ccc1);
2407             ccctest = 1.;  //HEpositivedirectionRecosignal5->SetBinError(i,0.01);
2408           }
2409         }  // for jphi
2410         if (ccctest > 0.) {
2411           //cout<<"888        kcountHEpositivedirectionRecosignal5   =     "<<kcountHEpositivedirectionRecosignal5  <<"   jeta-41=     "<< jeta-41 <<endl;
2412           c3x5->cd(kcountHEpositivedirectionRecosignal5);
2413           HEpositivedirectionRecosignal5->SetMarkerStyle(20);
2414           HEpositivedirectionRecosignal5->SetMarkerSize(0.4);
2415           HEpositivedirectionRecosignal5->GetYaxis()->SetLabelSize(0.04);
2416           HEpositivedirectionRecosignal5->SetXTitle("HEpositivedirectionRecosignal5 \b");
2417           HEpositivedirectionRecosignal5->SetMarkerColor(2);
2418           HEpositivedirectionRecosignal5->SetLineColor(0);
2419           gPad->SetGridy();
2420           gPad->SetGridx();
2421           //       gPad->SetLogy();
2422           if (kcountHEpositivedirectionRecosignal5 == 1)
2423             HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 17; depth = 5 \b");
2424           if (kcountHEpositivedirectionRecosignal5 == 2)
2425             HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 18; depth = 5 \b");
2426           if (kcountHEpositivedirectionRecosignal5 == 3)
2427             HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 19; depth = 5 \b");
2428           if (kcountHEpositivedirectionRecosignal5 == 4)
2429             HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 20; depth = 5 \b");
2430           if (kcountHEpositivedirectionRecosignal5 == 5)
2431             HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 21; depth = 5 \b");
2432           if (kcountHEpositivedirectionRecosignal5 == 6)
2433             HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 22; depth = 5 \b");
2434           if (kcountHEpositivedirectionRecosignal5 == 7)
2435             HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 23; depth = 5 \b");
2436           if (kcountHEpositivedirectionRecosignal5 == 8)
2437             HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 24; depth = 5 \b");
2438           if (kcountHEpositivedirectionRecosignal5 == 9)
2439             HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 25; depth = 5 \b");
2440           if (kcountHEpositivedirectionRecosignal5 == 10)
2441             HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 26; depth = 5 \b");
2442           if (kcountHEpositivedirectionRecosignal5 == 11)
2443             HEpositivedirectionRecosignal5->SetXTitle("R for HE+ jeta = 27; depth = 5 \b");
2444           HEpositivedirectionRecosignal5->Draw("Error");
2445           kcountHEpositivedirectionRecosignal5++;
2446           if (kcountHEpositivedirectionRecosignal5 > 11)
2447             break;  // 4x6 = 24
2448         }           //ccctest>0
2449 
2450       }  // for i
2451     }    //if(jeta-41 >= 0)
2452   }      //for jeta
2453   /////////////////
2454   c3x5->Update();
2455   c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth5HE.png");
2456   c3x5->Clear();
2457   // clean-up
2458   if (h2CeffHEpositivedirectionRecosignal5)
2459     delete h2CeffHEpositivedirectionRecosignal5;
2460   //========================================================================================== 9
2461   //======================================================================
2462   //======================================================================1D plot: R vs phi , different eta,  depth=6
2463   //cout<<"      1D plot: R vs phi , different eta,  depth=6 *****" <<endl;
2464   c3x5->Clear();
2465   /////////////////
2466   c3x5->Divide(3, 5);
2467   c3x5->cd(1);
2468   int kcountHEpositivedirectionRecosignal6 = 1;
2469   TH1F* h2CeffHEpositivedirectionRecosignal6 = new TH1F("h2CeffHEpositivedirectionRecosignal6", "", nphi, 0., 72.);
2470 
2471   for (int jeta = 0; jeta < njeta; jeta++) {
2472     // positivedirectionRecosignal:
2473     if (jeta - 41 >= 0) {
2474       //         for (int i=0;i<ndepth;i++) {
2475       // depth=6
2476       for (int i = 5; i < 6; i++) {
2477         TH1F* HEpositivedirectionRecosignal6 = (TH1F*)h2CeffHEpositivedirectionRecosignal6->Clone("twod1");
2478 
2479         float ccctest = 0;  // to avoid empty massive elements
2480         for (int jphi = 0; jphi < nphi; jphi++) {
2481           double ccc1 = arecosignalhe[i][jeta][jphi];
2482           if (ccc1 != 0.) {
2483             HEpositivedirectionRecosignal6->Fill(jphi, ccc1);
2484             ccctest = 1.;  //HEpositivedirectionRecosignal6->SetBinError(i,0.01);
2485           }
2486         }  // for jphi
2487         if (ccctest > 0.) {
2488           //cout<<"999        kcountHEpositivedirectionRecosignal6   =     "<<kcountHEpositivedirectionRecosignal6  <<"   jeta-41=     "<< jeta-41 <<endl;
2489           c3x5->cd(kcountHEpositivedirectionRecosignal6);
2490           HEpositivedirectionRecosignal6->SetMarkerStyle(20);
2491           HEpositivedirectionRecosignal6->SetMarkerSize(0.4);
2492           HEpositivedirectionRecosignal6->GetYaxis()->SetLabelSize(0.04);
2493           HEpositivedirectionRecosignal6->SetXTitle("HEpositivedirectionRecosignal6 \b");
2494           HEpositivedirectionRecosignal6->SetMarkerColor(2);
2495           HEpositivedirectionRecosignal6->SetLineColor(0);
2496           gPad->SetGridy();
2497           gPad->SetGridx();
2498           //       gPad->SetLogy();
2499           if (kcountHEpositivedirectionRecosignal6 == 1)
2500             HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 18; depth = 6 \b");
2501           if (kcountHEpositivedirectionRecosignal6 == 2)
2502             HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 19; depth = 6 \b");
2503           if (kcountHEpositivedirectionRecosignal6 == 3)
2504             HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 20; depth = 6 \b");
2505           if (kcountHEpositivedirectionRecosignal6 == 4)
2506             HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 21; depth = 6 \b");
2507           if (kcountHEpositivedirectionRecosignal6 == 5)
2508             HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 22; depth = 6 \b");
2509           if (kcountHEpositivedirectionRecosignal6 == 6)
2510             HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 23; depth = 6 \b");
2511           if (kcountHEpositivedirectionRecosignal6 == 7)
2512             HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 24; depth = 6 \b");
2513           if (kcountHEpositivedirectionRecosignal6 == 8)
2514             HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 25; depth = 6 \b");
2515           if (kcountHEpositivedirectionRecosignal6 == 9)
2516             HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 26; depth = 6 \b");
2517           if (kcountHEpositivedirectionRecosignal6 == 10)
2518             HEpositivedirectionRecosignal6->SetXTitle("R for HE+ jeta = 27; depth = 6 \b");
2519           HEpositivedirectionRecosignal6->Draw("Error");
2520           kcountHEpositivedirectionRecosignal6++;
2521           if (kcountHEpositivedirectionRecosignal6 > 10)
2522             break;  // 4x6 = 24
2523         }           //ccctest>0
2524 
2525       }  // for i
2526     }    //if(jeta-41 >= 0)
2527   }      //for jeta
2528   /////////////////
2529   c3x5->Update();
2530   c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth6HE.png");
2531   c3x5->Clear();
2532   // clean-up
2533   if (h2CeffHEpositivedirectionRecosignal6)
2534     delete h2CeffHEpositivedirectionRecosignal6;
2535   //========================================================================================== 10
2536   //======================================================================
2537   //======================================================================1D plot: R vs phi , different eta,  depth=7
2538   //cout<<"      1D plot: R vs phi , different eta,  depth=7 *****" <<endl;
2539   c3x5->Clear();
2540   /////////////////
2541   c3x5->Divide(3, 5);
2542   c3x5->cd(1);
2543   int kcountHEpositivedirectionRecosignal7 = 1;
2544   TH1F* h2CeffHEpositivedirectionRecosignal7 = new TH1F("h2CeffHEpositivedirectionRecosignal7", "", nphi, 0., 72.);
2545 
2546   for (int jeta = 0; jeta < njeta; jeta++) {
2547     // positivedirectionRecosignal:
2548     if (jeta - 41 >= 0) {
2549       //         for (int i=0;i<ndepth;i++) {
2550       // depth=7
2551       for (int i = 6; i < 7; i++) {
2552         TH1F* HEpositivedirectionRecosignal7 = (TH1F*)h2CeffHEpositivedirectionRecosignal7->Clone("twod1");
2553 
2554         float ccctest = 0;  // to avoid empty massive elements
2555         for (int jphi = 0; jphi < nphi; jphi++) {
2556           double ccc1 = arecosignalhe[i][jeta][jphi];
2557           if (ccc1 != 0.) {
2558             HEpositivedirectionRecosignal7->Fill(jphi, ccc1);
2559             ccctest = 1.;  //HEpositivedirectionRecosignal7->SetBinError(i,0.01);
2560           }
2561         }  // for jphi
2562         if (ccctest > 0.) {
2563           //cout<<"1010       kcountHEpositivedirectionRecosignal7   =     "<<kcountHEpositivedirectionRecosignal7  <<"   jeta-41=     "<< jeta-41 <<endl;
2564           c3x5->cd(kcountHEpositivedirectionRecosignal7);
2565           HEpositivedirectionRecosignal7->SetMarkerStyle(20);
2566           HEpositivedirectionRecosignal7->SetMarkerSize(0.4);
2567           HEpositivedirectionRecosignal7->GetYaxis()->SetLabelSize(0.04);
2568           HEpositivedirectionRecosignal7->SetXTitle("HEpositivedirectionRecosignal7 \b");
2569           HEpositivedirectionRecosignal7->SetMarkerColor(2);
2570           HEpositivedirectionRecosignal7->SetLineColor(0);
2571           gPad->SetGridy();
2572           gPad->SetGridx();
2573           //       gPad->SetLogy();
2574           if (kcountHEpositivedirectionRecosignal7 == 1)
2575             HEpositivedirectionRecosignal7->SetXTitle("R for HE+ jeta = 25; depth = 7 \b");
2576           if (kcountHEpositivedirectionRecosignal7 == 2)
2577             HEpositivedirectionRecosignal7->SetXTitle("R for HE+ jeta = 26; depth = 7 \b");
2578           if (kcountHEpositivedirectionRecosignal7 == 3)
2579             HEpositivedirectionRecosignal7->SetXTitle("R for HE+ jeta = 27; depth = 7 \b");
2580           HEpositivedirectionRecosignal7->Draw("Error");
2581           kcountHEpositivedirectionRecosignal7++;
2582           if (kcountHEpositivedirectionRecosignal7 > 3)
2583             break;  //
2584         }           //ccctest>0
2585 
2586       }  // for i
2587     }    //if(jeta-41 >= 0)
2588   }      //for jeta
2589   /////////////////
2590   c3x5->Update();
2591   c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth7HE.png");
2592   c3x5->Clear();
2593   // clean-up
2594   if (h2CeffHEpositivedirectionRecosignal7)
2595     delete h2CeffHEpositivedirectionRecosignal7;
2596 
2597   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2598   //========================================================================================== 1114
2599   //======================================================================
2600   //======================================================================1D plot: R vs phi , different eta,  depth=1
2601   //cout<<"      1D plot: R vs phi , different eta,  depth=1 *****" <<endl;
2602   c3x5->Clear();
2603   /////////////////
2604   c3x5->Divide(3, 5);
2605   c3x5->cd(1);
2606   int kcountHEnegativedirectionRecosignal1 = 1;
2607   TH1F* h2CeffHEnegativedirectionRecosignal1 = new TH1F("h2CeffHEnegativedirectionRecosignal1", "", nphi, 0., 72.);
2608   for (int jeta = 0; jeta < njeta; jeta++) {
2609     // negativedirectionRecosignal:
2610     if (jeta - 41 < 0) {
2611       //         for (int i=0;i<ndepth;i++) {
2612       // depth=1
2613       for (int i = 0; i < 1; i++) {
2614         TH1F* HEnegativedirectionRecosignal1 = (TH1F*)h2CeffHEnegativedirectionRecosignal1->Clone("twod1");
2615         float ccctest = 0;  // to avoid empty massive elements
2616         for (int jphi = 0; jphi < nphi; jphi++) {
2617           double ccc1 = arecosignalhe[i][jeta][jphi];
2618           if (ccc1 != 0.) {
2619             HEnegativedirectionRecosignal1->Fill(jphi, ccc1);
2620             ccctest = 1.;  //HEnegativedirectionRecosignal1->SetBinError(i,0.01);
2621           }
2622         }  // for jphi
2623         if (ccctest > 0.) {
2624           //      cout<<"444        kcountHEnegativedirectionRecosignal1   =     "<<kcountHEnegativedirectionRecosignal1  <<"   jeta-41=     "<< jeta-41 <<endl;
2625           c3x5->cd(kcountHEnegativedirectionRecosignal1);
2626           HEnegativedirectionRecosignal1->SetMarkerStyle(20);
2627           HEnegativedirectionRecosignal1->SetMarkerSize(0.4);
2628           HEnegativedirectionRecosignal1->GetYaxis()->SetLabelSize(0.04);
2629           HEnegativedirectionRecosignal1->SetXTitle("HEnegativedirectionRecosignal1 \b");
2630           HEnegativedirectionRecosignal1->SetMarkerColor(2);
2631           HEnegativedirectionRecosignal1->SetLineColor(0);
2632           gPad->SetGridy();
2633           gPad->SetGridx();
2634           //       gPad->SetLogy();
2635           if (kcountHEnegativedirectionRecosignal1 == 1)
2636             HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-29; depth = 1 \b");
2637           if (kcountHEnegativedirectionRecosignal1 == 2)
2638             HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-28; depth = 1 \b");
2639           if (kcountHEnegativedirectionRecosignal1 == 3)
2640             HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-27; depth = 1 \b");
2641           if (kcountHEnegativedirectionRecosignal1 == 4)
2642             HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-26; depth = 1 \b");
2643           if (kcountHEnegativedirectionRecosignal1 == 5)
2644             HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-25; depth = 1 \b");
2645           if (kcountHEnegativedirectionRecosignal1 == 6)
2646             HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-24; depth = 1 \b");
2647           if (kcountHEnegativedirectionRecosignal1 == 7)
2648             HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-23; depth = 1 \b");
2649           if (kcountHEnegativedirectionRecosignal1 == 8)
2650             HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-22; depth = 1 \b");
2651           if (kcountHEnegativedirectionRecosignal1 == 9)
2652             HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-21; depth = 1 \b");
2653           if (kcountHEnegativedirectionRecosignal1 == 10)
2654             HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-20; depth = 1 \b");
2655           if (kcountHEnegativedirectionRecosignal1 == 11)
2656             HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-19; depth = 1 \b");
2657           if (kcountHEnegativedirectionRecosignal1 == 12)
2658             HEnegativedirectionRecosignal1->SetXTitle("R for HE- jeta =-18; depth = 1 \b");
2659           HEnegativedirectionRecosignal1->Draw("Error");
2660           kcountHEnegativedirectionRecosignal1++;
2661           if (kcountHEnegativedirectionRecosignal1 > 12)
2662             break;  // 4x6 = 24
2663         }           //ccctest>0
2664 
2665       }  // for i
2666     }    //if(jeta-41 < 0)
2667   }      //for jeta
2668   /////////////////
2669   c3x5->Update();
2670   c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth1HE.png");
2671   c3x5->Clear();
2672   // clean-up
2673   if (h2CeffHEnegativedirectionRecosignal1)
2674     delete h2CeffHEnegativedirectionRecosignal1;
2675 
2676   //========================================================================================== 1115
2677   //======================================================================
2678   //======================================================================1D plot: R vs phi , different eta,  depth=2
2679   //  cout<<"      1D plot: R vs phi , different eta,  depth=2 *****" <<endl;
2680   c3x5->Clear();
2681   /////////////////
2682   c3x5->Divide(3, 5);
2683   c3x5->cd(1);
2684   int kcountHEnegativedirectionRecosignal2 = 1;
2685   TH1F* h2CeffHEnegativedirectionRecosignal2 = new TH1F("h2CeffHEnegativedirectionRecosignal2", "", nphi, 0., 72.);
2686   for (int jeta = 0; jeta < njeta; jeta++) {
2687     // negativedirectionRecosignal:
2688     if (jeta - 41 < 0) {
2689       //         for (int i=0;i<ndepth;i++) {
2690       // depth=2
2691       for (int i = 1; i < 2; i++) {
2692         TH1F* HEnegativedirectionRecosignal2 = (TH1F*)h2CeffHEnegativedirectionRecosignal2->Clone("twod1");
2693         float ccctest = 0;  // to avoid empty massive elements
2694         for (int jphi = 0; jphi < nphi; jphi++) {
2695           double ccc1 = arecosignalhe[i][jeta][jphi];
2696           if (ccc1 != 0.) {
2697             HEnegativedirectionRecosignal2->Fill(jphi, ccc1);
2698             ccctest = 1.;  //HEnegativedirectionRecosignal2->SetBinError(i,0.01);
2699           }
2700         }  // for jphi
2701         if (ccctest > 0.) {
2702           //cout<<"555        kcountHEnegativedirectionRecosignal2   =     "<<kcountHEnegativedirectionRecosignal2  <<"   jeta-41=     "<< jeta-41 <<endl;
2703           c3x5->cd(kcountHEnegativedirectionRecosignal2);
2704           HEnegativedirectionRecosignal2->SetMarkerStyle(20);
2705           HEnegativedirectionRecosignal2->SetMarkerSize(0.4);
2706           HEnegativedirectionRecosignal2->GetYaxis()->SetLabelSize(0.04);
2707           HEnegativedirectionRecosignal2->SetXTitle("HEnegativedirectionRecosignal2 \b");
2708           HEnegativedirectionRecosignal2->SetMarkerColor(2);
2709           HEnegativedirectionRecosignal2->SetLineColor(0);
2710           gPad->SetGridy();
2711           gPad->SetGridx();
2712           //       gPad->SetLogy();
2713           if (kcountHEnegativedirectionRecosignal2 == 1)
2714             HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-29; depth = 2 \b");
2715           if (kcountHEnegativedirectionRecosignal2 == 2)
2716             HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-28; depth = 2 \b");
2717           if (kcountHEnegativedirectionRecosignal2 == 3)
2718             HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-27; depth = 2 \b");
2719           if (kcountHEnegativedirectionRecosignal2 == 4)
2720             HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-26; depth = 2 \b");
2721           if (kcountHEnegativedirectionRecosignal2 == 5)
2722             HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-25; depth = 2 \b");
2723           if (kcountHEnegativedirectionRecosignal2 == 6)
2724             HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-24; depth = 2 \b");
2725           if (kcountHEnegativedirectionRecosignal2 == 7)
2726             HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-23; depth = 2 \b");
2727           if (kcountHEnegativedirectionRecosignal2 == 8)
2728             HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-22; depth = 2 \b");
2729           if (kcountHEnegativedirectionRecosignal2 == 9)
2730             HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-21; depth = 2 \b");
2731           if (kcountHEnegativedirectionRecosignal2 == 10)
2732             HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-20; depth = 2 \b");
2733           if (kcountHEnegativedirectionRecosignal2 == 11)
2734             HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-19; depth = 2 \b");
2735           if (kcountHEnegativedirectionRecosignal2 == 12)
2736             HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-18; depth = 2 \b");
2737           if (kcountHEnegativedirectionRecosignal2 == 13)
2738             HEnegativedirectionRecosignal2->SetXTitle("R for HE- jeta =-17; depth = 2 \b");
2739           HEnegativedirectionRecosignal2->Draw("Error");
2740           kcountHEnegativedirectionRecosignal2++;
2741           if (kcountHEnegativedirectionRecosignal2 > 13)
2742             break;  // 4x6 = 24
2743         }           //ccctest>0
2744 
2745       }  // for i
2746     }    //if(jeta-41 < 0)
2747   }      //for jeta
2748   /////////////////
2749   c3x5->Update();
2750   c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth2HE.png");
2751   c3x5->Clear();
2752   // clean-up
2753   if (h2CeffHEnegativedirectionRecosignal2)
2754     delete h2CeffHEnegativedirectionRecosignal2;
2755   //========================================================================================== 1116
2756   //======================================================================
2757   //======================================================================1D plot: R vs phi , different eta,  depth=3
2758   //cout<<"      1D plot: R vs phi , different eta,  depth=3 *****" <<endl;
2759   c3x5->Clear();
2760   /////////////////
2761   c3x5->Divide(3, 5);
2762   c3x5->cd(1);
2763   int kcountHEnegativedirectionRecosignal3 = 1;
2764   TH1F* h2CeffHEnegativedirectionRecosignal3 = new TH1F("h2CeffHEnegativedirectionRecosignal3", "", nphi, 0., 72.);
2765   for (int jeta = 0; jeta < njeta; jeta++) {
2766     // negativedirectionRecosignal:
2767     if (jeta - 41 < 0) {
2768       //         for (int i=0;i<ndepth;i++) {
2769       // depth=3
2770       for (int i = 2; i < 3; i++) {
2771         TH1F* HEnegativedirectionRecosignal3 = (TH1F*)h2CeffHEnegativedirectionRecosignal3->Clone("twod1");
2772         float ccctest = 0;  // to avoid empty massive elements
2773         for (int jphi = 0; jphi < nphi; jphi++) {
2774           double ccc1 = arecosignalhe[i][jeta][jphi];
2775           if (ccc1 != 0.) {
2776             HEnegativedirectionRecosignal3->Fill(jphi, ccc1);
2777             ccctest = 1.;  //HEnegativedirectionRecosignal3->SetBinError(i,0.01);
2778           }
2779         }  // for jphi
2780         if (ccctest > 0.) {
2781           //cout<<"666        kcountHEnegativedirectionRecosignal3   =     "<<kcountHEnegativedirectionRecosignal3  <<"   jeta-41=     "<< jeta-41 <<endl;
2782           c3x5->cd(kcountHEnegativedirectionRecosignal3);
2783           HEnegativedirectionRecosignal3->SetMarkerStyle(20);
2784           HEnegativedirectionRecosignal3->SetMarkerSize(0.4);
2785           HEnegativedirectionRecosignal3->GetYaxis()->SetLabelSize(0.04);
2786           HEnegativedirectionRecosignal3->SetXTitle("HEnegativedirectionRecosignal3 \b");
2787           HEnegativedirectionRecosignal3->SetMarkerColor(2);
2788           HEnegativedirectionRecosignal3->SetLineColor(0);
2789           gPad->SetGridy();
2790           gPad->SetGridx();
2791           //       gPad->SetLogy();
2792           if (kcountHEnegativedirectionRecosignal3 == 1)
2793             HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-29; depth = 3 \b");
2794           if (kcountHEnegativedirectionRecosignal3 == 2)
2795             HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-28; depth = 3 \b");
2796           if (kcountHEnegativedirectionRecosignal3 == 3)
2797             HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-27; depth = 3 \b");
2798           if (kcountHEnegativedirectionRecosignal3 == 4)
2799             HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-26; depth = 3 \b");
2800           if (kcountHEnegativedirectionRecosignal3 == 5)
2801             HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-25; depth = 3 \b");
2802           if (kcountHEnegativedirectionRecosignal3 == 6)
2803             HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-24; depth = 3 \b");
2804           if (kcountHEnegativedirectionRecosignal3 == 7)
2805             HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-23; depth = 3 \b");
2806           if (kcountHEnegativedirectionRecosignal3 == 8)
2807             HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-22; depth = 3 \b");
2808           if (kcountHEnegativedirectionRecosignal3 == 9)
2809             HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-21; depth = 3 \b");
2810           if (kcountHEnegativedirectionRecosignal3 == 10)
2811             HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-20; depth = 3 \b");
2812           if (kcountHEnegativedirectionRecosignal3 == 11)
2813             HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-19; depth = 3 \b");
2814           if (kcountHEnegativedirectionRecosignal3 == 12)
2815             HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-18; depth = 3 \b");
2816           if (kcountHEnegativedirectionRecosignal3 == 13)
2817             HEnegativedirectionRecosignal3->SetXTitle("R for HE- jeta =-17; depth = 3 \b");
2818           HEnegativedirectionRecosignal3->Draw("Error");
2819           kcountHEnegativedirectionRecosignal3++;
2820           if (kcountHEnegativedirectionRecosignal3 > 13)
2821             break;  // 4x6 = 24
2822         }           //ccctest>0
2823 
2824       }  // for i
2825     }    //if(jeta-41 < 0)
2826   }      //for jeta
2827   /////////////////
2828   c3x5->Update();
2829   c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth3HE.png");
2830   c3x5->Clear();
2831   // clean-up
2832   if (h2CeffHEnegativedirectionRecosignal3)
2833     delete h2CeffHEnegativedirectionRecosignal3;
2834   //========================================================================================== 1117
2835   //======================================================================
2836   //======================================================================1D plot: R vs phi , different eta,  depth=4
2837   //cout<<"      1D plot: R vs phi , different eta,  depth=4 *****" <<endl;
2838   c3x5->Clear();
2839   /////////////////
2840   c3x5->Divide(3, 5);
2841   c3x5->cd(1);
2842   int kcountHEnegativedirectionRecosignal4 = 1;
2843   TH1F* h2CeffHEnegativedirectionRecosignal4 = new TH1F("h2CeffHEnegativedirectionRecosignal4", "", nphi, 0., 72.);
2844 
2845   for (int jeta = 0; jeta < njeta; jeta++) {
2846     // negativedirectionRecosignal:
2847     if (jeta - 41 < 0) {
2848       //         for (int i=0;i<ndepth;i++) {
2849       // depth=4
2850       for (int i = 3; i < 4; i++) {
2851         TH1F* HEnegativedirectionRecosignal4 = (TH1F*)h2CeffHEnegativedirectionRecosignal4->Clone("twod1");
2852 
2853         float ccctest = 0;  // to avoid empty massive elements
2854         for (int jphi = 0; jphi < nphi; jphi++) {
2855           double ccc1 = arecosignalhe[i][jeta][jphi];
2856           if (ccc1 != 0.) {
2857             HEnegativedirectionRecosignal4->Fill(jphi, ccc1);
2858             ccctest = 1.;  //HEnegativedirectionRecosignal4->SetBinError(i,0.01);
2859           }
2860         }  // for jphi
2861         if (ccctest > 0.) {
2862           //cout<<"777        kcountHEnegativedirectionRecosignal4   =     "<<kcountHEnegativedirectionRecosignal4  <<"   jeta-41=     "<< jeta-41 <<endl;
2863           c3x5->cd(kcountHEnegativedirectionRecosignal4);
2864           HEnegativedirectionRecosignal4->SetMarkerStyle(20);
2865           HEnegativedirectionRecosignal4->SetMarkerSize(0.4);
2866           HEnegativedirectionRecosignal4->GetYaxis()->SetLabelSize(0.04);
2867           HEnegativedirectionRecosignal4->SetXTitle("HEnegativedirectionRecosignal4 \b");
2868           HEnegativedirectionRecosignal4->SetMarkerColor(2);
2869           HEnegativedirectionRecosignal4->SetLineColor(0);
2870           gPad->SetGridy();
2871           gPad->SetGridx();
2872           //       gPad->SetLogy();
2873           if (kcountHEnegativedirectionRecosignal4 == 1)
2874             HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-28; depth = 4 \b");
2875           if (kcountHEnegativedirectionRecosignal4 == 2)
2876             HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-27; depth = 4 \b");
2877           if (kcountHEnegativedirectionRecosignal4 == 3)
2878             HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-26; depth = 4 \b");
2879           if (kcountHEnegativedirectionRecosignal4 == 4)
2880             HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-25; depth = 4 \b");
2881           if (kcountHEnegativedirectionRecosignal4 == 5)
2882             HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-24; depth = 4 \b");
2883           if (kcountHEnegativedirectionRecosignal4 == 6)
2884             HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-23; depth = 4 \b");
2885           if (kcountHEnegativedirectionRecosignal4 == 7)
2886             HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-22; depth = 4 \b");
2887           if (kcountHEnegativedirectionRecosignal4 == 8)
2888             HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-21; depth = 4 \b");
2889           if (kcountHEnegativedirectionRecosignal4 == 9)
2890             HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-20; depth = 4 \b");
2891           if (kcountHEnegativedirectionRecosignal4 == 10)
2892             HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-19; depth = 4 \b");
2893           if (kcountHEnegativedirectionRecosignal4 == 11)
2894             HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-18; depth = 4 \b");
2895           if (kcountHEnegativedirectionRecosignal4 == 12)
2896             HEnegativedirectionRecosignal4->SetXTitle("R for HE- jeta =-16; depth = 4 \b");
2897           HEnegativedirectionRecosignal4->Draw("Error");
2898           kcountHEnegativedirectionRecosignal4++;
2899           if (kcountHEnegativedirectionRecosignal4 > 12)
2900             break;  // 4x6 = 24
2901         }           //ccctest>0
2902 
2903       }  // for i
2904     }    //if(jeta-41 < 0)
2905   }      //for jeta
2906   /////////////////
2907   c3x5->Update();
2908   c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth4HE.png");
2909   c3x5->Clear();
2910   // clean-up
2911   if (h2CeffHEnegativedirectionRecosignal4)
2912     delete h2CeffHEnegativedirectionRecosignal4;
2913   //========================================================================================== 1118
2914   //======================================================================
2915   //======================================================================1D plot: R vs phi , different eta,  depth=5
2916   //cout<<"      1D plot: R vs phi , different eta,  depth=5 *****" <<endl;
2917   c3x5->Clear();
2918   /////////////////
2919   c3x5->Divide(3, 5);
2920   c3x5->cd(1);
2921   int kcountHEnegativedirectionRecosignal5 = 1;
2922   TH1F* h2CeffHEnegativedirectionRecosignal5 = new TH1F("h2CeffHEnegativedirectionRecosignal5", "", nphi, 0., 72.);
2923 
2924   for (int jeta = 0; jeta < njeta; jeta++) {
2925     // negativedirectionRecosignal:
2926     if (jeta - 41 < 0) {
2927       //         for (int i=0;i<ndepth;i++) {
2928       // depth=5
2929       for (int i = 4; i < 5; i++) {
2930         TH1F* HEnegativedirectionRecosignal5 = (TH1F*)h2CeffHEnegativedirectionRecosignal5->Clone("twod1");
2931 
2932         float ccctest = 0;  // to avoid empty massive elements
2933         for (int jphi = 0; jphi < nphi; jphi++) {
2934           //           cout<<"888  initial      kcountHEnegativedirectionRecosignal5   =     "<<kcountHEnegativedirectionRecosignal5  <<"   jeta-41=     "<< jeta-41 <<"   jphi=     "<< jphi <<"   arecosignalhe[i][jeta][jphi]=     "<< arecosignalhe[i][jeta][jphi] <<"  depth=     "<< i <<endl;
2935 
2936           double ccc1 = arecosignalhe[i][jeta][jphi];
2937           if (ccc1 != 0.) {
2938             HEnegativedirectionRecosignal5->Fill(jphi, ccc1);
2939             ccctest = 1.;  //HEnegativedirectionRecosignal5->SetBinError(i,0.01);
2940           }
2941         }  // for jphi
2942         if (ccctest > 0.) {
2943           //cout<<"888        kcountHEnegativedirectionRecosignal5   =     "<<kcountHEnegativedirectionRecosignal5  <<"   jeta-41=     "<< jeta-41 <<endl;
2944           c3x5->cd(kcountHEnegativedirectionRecosignal5);
2945           HEnegativedirectionRecosignal5->SetMarkerStyle(20);
2946           HEnegativedirectionRecosignal5->SetMarkerSize(0.4);
2947           HEnegativedirectionRecosignal5->GetYaxis()->SetLabelSize(0.04);
2948           HEnegativedirectionRecosignal5->SetXTitle("HEnegativedirectionRecosignal5 \b");
2949           HEnegativedirectionRecosignal5->SetMarkerColor(2);
2950           HEnegativedirectionRecosignal5->SetLineColor(0);
2951           gPad->SetGridy();
2952           gPad->SetGridx();
2953           //       gPad->SetLogy();
2954           if (kcountHEnegativedirectionRecosignal5 == 1)
2955             HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-28; depth = 5 \b");
2956           if (kcountHEnegativedirectionRecosignal5 == 2)
2957             HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-27; depth = 5 \b");
2958           if (kcountHEnegativedirectionRecosignal5 == 3)
2959             HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-26; depth = 5 \b");
2960           if (kcountHEnegativedirectionRecosignal5 == 4)
2961             HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-25; depth = 5 \b");
2962           if (kcountHEnegativedirectionRecosignal5 == 5)
2963             HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-24; depth = 5 \b");
2964           if (kcountHEnegativedirectionRecosignal5 == 6)
2965             HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-23; depth = 5 \b");
2966           if (kcountHEnegativedirectionRecosignal5 == 7)
2967             HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-22; depth = 5 \b");
2968           if (kcountHEnegativedirectionRecosignal5 == 8)
2969             HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-21; depth = 5 \b");
2970           if (kcountHEnegativedirectionRecosignal5 == 9)
2971             HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-20; depth = 5 \b");
2972           if (kcountHEnegativedirectionRecosignal5 == 10)
2973             HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-19; depth = 5 \b");
2974           if (kcountHEnegativedirectionRecosignal5 == 11)
2975             HEnegativedirectionRecosignal5->SetXTitle("R for HE- jeta =-18; depth = 5 \b");
2976           HEnegativedirectionRecosignal5->Draw("Error");
2977           kcountHEnegativedirectionRecosignal5++;
2978           if (kcountHEnegativedirectionRecosignal5 > 11)
2979             break;  // 4x6 = 24
2980         }           //ccctest>0
2981 
2982       }  // for i
2983     }    //if(jeta-41 < 0)
2984   }      //for jeta
2985   /////////////////
2986   c3x5->Update();
2987   c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth5HE.png");
2988   c3x5->Clear();
2989   // clean-up
2990   if (h2CeffHEnegativedirectionRecosignal5)
2991     delete h2CeffHEnegativedirectionRecosignal5;
2992   //========================================================================================== 1119
2993   //======================================================================
2994   //======================================================================1D plot: R vs phi , different eta,  depth=6
2995   //cout<<"      1D plot: R vs phi , different eta,  depth=6 *****" <<endl;
2996   c3x5->Clear();
2997   /////////////////
2998   c3x5->Divide(3, 5);
2999   c3x5->cd(1);
3000   int kcountHEnegativedirectionRecosignal6 = 1;
3001   TH1F* h2CeffHEnegativedirectionRecosignal6 = new TH1F("h2CeffHEnegativedirectionRecosignal6", "", nphi, 0., 72.);
3002 
3003   for (int jeta = 0; jeta < njeta; jeta++) {
3004     // negativedirectionRecosignal:
3005     if (jeta - 41 < 0) {
3006       //         for (int i=0;i<ndepth;i++) {
3007       // depth=6
3008       for (int i = 5; i < 6; i++) {
3009         TH1F* HEnegativedirectionRecosignal6 = (TH1F*)h2CeffHEnegativedirectionRecosignal6->Clone("twod1");
3010 
3011         float ccctest = 0;  // to avoid empty massive elements
3012         for (int jphi = 0; jphi < nphi; jphi++) {
3013           double ccc1 = arecosignalhe[i][jeta][jphi];
3014           if (ccc1 != 0.) {
3015             HEnegativedirectionRecosignal6->Fill(jphi, ccc1);
3016             ccctest = 1.;  //HEnegativedirectionRecosignal6->SetBinError(i,0.01);
3017           }
3018         }  // for jphi
3019         if (ccctest > 0.) {
3020           //cout<<"999        kcountHEnegativedirectionRecosignal6   =     "<<kcountHEnegativedirectionRecosignal6  <<"   jeta-41=     "<< jeta-41 <<endl;
3021           c3x5->cd(kcountHEnegativedirectionRecosignal6);
3022           HEnegativedirectionRecosignal6->SetMarkerStyle(20);
3023           HEnegativedirectionRecosignal6->SetMarkerSize(0.4);
3024           HEnegativedirectionRecosignal6->GetYaxis()->SetLabelSize(0.04);
3025           HEnegativedirectionRecosignal6->SetXTitle("HEnegativedirectionRecosignal6 \b");
3026           HEnegativedirectionRecosignal6->SetMarkerColor(2);
3027           HEnegativedirectionRecosignal6->SetLineColor(0);
3028           gPad->SetGridy();
3029           gPad->SetGridx();
3030           //       gPad->SetLogy();
3031           if (kcountHEnegativedirectionRecosignal6 == 1)
3032             HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-28; depth = 6 \b");
3033           if (kcountHEnegativedirectionRecosignal6 == 2)
3034             HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-27; depth = 6 \b");
3035           if (kcountHEnegativedirectionRecosignal6 == 3)
3036             HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-26; depth = 6 \b");
3037           if (kcountHEnegativedirectionRecosignal6 == 4)
3038             HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-25; depth = 6 \b");
3039           if (kcountHEnegativedirectionRecosignal6 == 5)
3040             HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-24; depth = 6 \b");
3041           if (kcountHEnegativedirectionRecosignal6 == 6)
3042             HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-23; depth = 6 \b");
3043           if (kcountHEnegativedirectionRecosignal6 == 7)
3044             HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-22; depth = 6 \b");
3045           if (kcountHEnegativedirectionRecosignal6 == 8)
3046             HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-21; depth = 6 \b");
3047           if (kcountHEnegativedirectionRecosignal6 == 9)
3048             HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-20; depth = 6 \b");
3049           if (kcountHEnegativedirectionRecosignal6 == 10)
3050             HEnegativedirectionRecosignal6->SetXTitle("R for HE- jeta =-19; depth = 6 \b");
3051           HEnegativedirectionRecosignal6->Draw("Error");
3052           kcountHEnegativedirectionRecosignal6++;
3053           if (kcountHEnegativedirectionRecosignal6 > 10)
3054             break;  // 4x6 = 24
3055         }           //ccctest>0
3056 
3057       }  // for i
3058     }    //if(jeta-41 < 0)
3059   }      //for jeta
3060   /////////////////
3061   c3x5->Update();
3062   c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth6HE.png");
3063   c3x5->Clear();
3064   // clean-up
3065   if (h2CeffHEnegativedirectionRecosignal6)
3066     delete h2CeffHEnegativedirectionRecosignal6;
3067   //========================================================================================== 11110
3068   //======================================================================
3069   //======================================================================1D plot: R vs phi , different eta,  depth=7
3070   //cout<<"      1D plot: R vs phi , different eta,  depth=7 *****" <<endl;
3071   c3x5->Clear();
3072   /////////////////
3073   c3x5->Divide(3, 5);
3074   c3x5->cd(1);
3075   int kcountHEnegativedirectionRecosignal7 = 1;
3076   TH1F* h2CeffHEnegativedirectionRecosignal7 = new TH1F("h2CeffHEnegativedirectionRecosignal7", "", nphi, 0., 72.);
3077 
3078   for (int jeta = 0; jeta < njeta; jeta++) {
3079     // negativedirectionRecosignal:
3080     if (jeta - 41 < 0) {
3081       //         for (int i=0;i<ndepth;i++) {
3082       // depth=7
3083       for (int i = 6; i < 7; i++) {
3084         TH1F* HEnegativedirectionRecosignal7 = (TH1F*)h2CeffHEnegativedirectionRecosignal7->Clone("twod1");
3085 
3086         float ccctest = 0;  // to avoid empty massive elements
3087         for (int jphi = 0; jphi < nphi; jphi++) {
3088           double ccc1 = arecosignalhe[i][jeta][jphi];
3089           if (ccc1 != 0.) {
3090             HEnegativedirectionRecosignal7->Fill(jphi, ccc1);
3091             ccctest = 1.;  //HEnegativedirectionRecosignal7->SetBinError(i,0.01);
3092           }
3093         }  // for jphi
3094         if (ccctest > 0.) {
3095           //cout<<"1010       kcountHEnegativedirectionRecosignal7   =     "<<kcountHEnegativedirectionRecosignal7  <<"   jeta-41=     "<< jeta-41 <<endl;
3096           c3x5->cd(kcountHEnegativedirectionRecosignal7);
3097           HEnegativedirectionRecosignal7->SetMarkerStyle(20);
3098           HEnegativedirectionRecosignal7->SetMarkerSize(0.4);
3099           HEnegativedirectionRecosignal7->GetYaxis()->SetLabelSize(0.04);
3100           HEnegativedirectionRecosignal7->SetXTitle("HEnegativedirectionRecosignal7 \b");
3101           HEnegativedirectionRecosignal7->SetMarkerColor(2);
3102           HEnegativedirectionRecosignal7->SetLineColor(0);
3103           gPad->SetGridy();
3104           gPad->SetGridx();
3105           //       gPad->SetLogy();
3106           if (kcountHEnegativedirectionRecosignal7 == 1)
3107             HEnegativedirectionRecosignal7->SetXTitle("R for HE- jeta =-28; depth = 7 \b");
3108           if (kcountHEnegativedirectionRecosignal7 == 2)
3109             HEnegativedirectionRecosignal7->SetXTitle("R for HE- jeta =-27; depth = 7 \b");
3110           if (kcountHEnegativedirectionRecosignal7 == 3)
3111             HEnegativedirectionRecosignal7->SetXTitle("R for HE- jeta =-26; depth = 7 \b");
3112           HEnegativedirectionRecosignal7->Draw("Error");
3113           kcountHEnegativedirectionRecosignal7++;
3114           if (kcountHEnegativedirectionRecosignal7 > 3)
3115             break;  // 4x6 = 24
3116         }           //ccctest>0
3117 
3118       }  // for i
3119     }    //if(jeta-41 < 0)
3120   }      //for jeta
3121   /////////////////
3122   c3x5->Update();
3123   c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth7HE.png");
3124   c3x5->Clear();
3125   // clean-up
3126   if (h2CeffHEnegativedirectionRecosignal7)
3127     delete h2CeffHEnegativedirectionRecosignal7;
3128 
3129   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3130 
3131   //                            DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD:
3132 
3133   //cout<<"    Start Vaiance: preparation  *****" <<endl;
3134   TH2F* recosignalVariance1HE1 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy2_HE1");
3135   TH2F* recosignalVariance0HE1 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HE1");
3136   TH2F* recosignalVarianceHE1 = (TH2F*)recosignalVariance1HE1->Clone("recosignalVarianceHE1");
3137   recosignalVarianceHE1->Divide(recosignalVariance1HE1, recosignalVariance0HE1, 1, 1, "B");
3138   TH2F* recosignalVariance1HE2 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy2_HE2");
3139   TH2F* recosignalVariance0HE2 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HE2");
3140   TH2F* recosignalVarianceHE2 = (TH2F*)recosignalVariance1HE2->Clone("recosignalVarianceHE2");
3141   recosignalVarianceHE2->Divide(recosignalVariance1HE2, recosignalVariance0HE2, 1, 1, "B");
3142   TH2F* recosignalVariance1HE3 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy2_HE3");
3143   TH2F* recosignalVariance0HE3 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HE3");
3144   TH2F* recosignalVarianceHE3 = (TH2F*)recosignalVariance1HE3->Clone("recosignalVarianceHE3");
3145   recosignalVarianceHE3->Divide(recosignalVariance1HE3, recosignalVariance0HE3, 1, 1, "B");
3146   TH2F* recosignalVariance1HE4 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy2_HE4");
3147   TH2F* recosignalVariance0HE4 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HE4");
3148   TH2F* recosignalVarianceHE4 = (TH2F*)recosignalVariance1HE4->Clone("recosignalVarianceHE4");
3149   recosignalVarianceHE4->Divide(recosignalVariance1HE4, recosignalVariance0HE4, 1, 1, "B");
3150   TH2F* recosignalVariance1HE5 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy2_HE5");
3151   TH2F* recosignalVariance0HE5 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HE5");
3152   TH2F* recosignalVarianceHE5 = (TH2F*)recosignalVariance1HE5->Clone("recosignalVarianceHE5");
3153   recosignalVarianceHE5->Divide(recosignalVariance1HE5, recosignalVariance0HE5, 1, 1, "B");
3154   TH2F* recosignalVariance1HE6 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy2_HE6");
3155   TH2F* recosignalVariance0HE6 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HE6");
3156   TH2F* recosignalVarianceHE6 = (TH2F*)recosignalVariance1HE6->Clone("recosignalVarianceHE6");
3157   recosignalVarianceHE6->Divide(recosignalVariance1HE6, recosignalVariance0HE6, 1, 1, "B");
3158   TH2F* recosignalVariance1HE7 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy2_HE7");
3159   TH2F* recosignalVariance0HE7 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HE7");
3160   TH2F* recosignalVarianceHE7 = (TH2F*)recosignalVariance1HE7->Clone("recosignalVarianceHE7");
3161   recosignalVarianceHE7->Divide(recosignalVariance1HE7, recosignalVariance0HE7, 1, 1, "B");
3162   //cout<<"      Vaiance: preparation DONE *****" <<endl;
3163   //====================================================================== put Vaiance=Dispersia = Sig**2=<R**2> - (<R>)**2 into massive recosignalvariancehe
3164   //                                                                                           = sum(R*R)/N - (sum(R)/N)**2
3165   for (int jeta = 0; jeta < njeta; jeta++) {
3166     //preparation for PHI normalization:
3167     double sumrecosignalHE0 = 0;
3168     int nsumrecosignalHE0 = 0;
3169     double sumrecosignalHE1 = 0;
3170     int nsumrecosignalHE1 = 0;
3171     double sumrecosignalHE2 = 0;
3172     int nsumrecosignalHE2 = 0;
3173     double sumrecosignalHE3 = 0;
3174     int nsumrecosignalHE3 = 0;
3175     double sumrecosignalHE4 = 0;
3176     int nsumrecosignalHE4 = 0;
3177     double sumrecosignalHE5 = 0;
3178     int nsumrecosignalHE5 = 0;
3179     double sumrecosignalHE6 = 0;
3180     int nsumrecosignalHE6 = 0;
3181     for (int jphi = 0; jphi < njphi; jphi++) {
3182       recosignalvariancehe[0][jeta][jphi] = recosignalVarianceHE1->GetBinContent(jeta + 1, jphi + 1);
3183       recosignalvariancehe[1][jeta][jphi] = recosignalVarianceHE2->GetBinContent(jeta + 1, jphi + 1);
3184       recosignalvariancehe[2][jeta][jphi] = recosignalVarianceHE3->GetBinContent(jeta + 1, jphi + 1);
3185       recosignalvariancehe[3][jeta][jphi] = recosignalVarianceHE4->GetBinContent(jeta + 1, jphi + 1);
3186       recosignalvariancehe[4][jeta][jphi] = recosignalVarianceHE5->GetBinContent(jeta + 1, jphi + 1);
3187       recosignalvariancehe[5][jeta][jphi] = recosignalVarianceHE6->GetBinContent(jeta + 1, jphi + 1);
3188       recosignalvariancehe[6][jeta][jphi] = recosignalVarianceHE7->GetBinContent(jeta + 1, jphi + 1);
3189       if (recosignalvariancehe[0][jeta][jphi] > 0.) {
3190         sumrecosignalHE0 += recosignalvariancehe[0][jeta][jphi];
3191         ++nsumrecosignalHE0;
3192       }
3193       if (recosignalvariancehe[1][jeta][jphi] > 0.) {
3194         sumrecosignalHE1 += recosignalvariancehe[1][jeta][jphi];
3195         ++nsumrecosignalHE1;
3196       }
3197       if (recosignalvariancehe[2][jeta][jphi] > 0.) {
3198         sumrecosignalHE2 += recosignalvariancehe[2][jeta][jphi];
3199         ++nsumrecosignalHE2;
3200       }
3201       if (recosignalvariancehe[3][jeta][jphi] > 0.) {
3202         sumrecosignalHE3 += recosignalvariancehe[3][jeta][jphi];
3203         ++nsumrecosignalHE3;
3204       }
3205       if (recosignalvariancehe[4][jeta][jphi] > 0.) {
3206         sumrecosignalHE4 += recosignalvariancehe[4][jeta][jphi];
3207         ++nsumrecosignalHE4;
3208       }
3209       if (recosignalvariancehe[5][jeta][jphi] > 0.) {
3210         sumrecosignalHE5 += recosignalvariancehe[5][jeta][jphi];
3211         ++nsumrecosignalHE5;
3212       }
3213       if (recosignalvariancehe[6][jeta][jphi] > 0.) {
3214         sumrecosignalHE6 += recosignalvariancehe[6][jeta][jphi];
3215         ++nsumrecosignalHE6;
3216       }
3217     }  // phi
3218     // PHI normalization :
3219     for (int jphi = 0; jphi < njphi; jphi++) {
3220       if (recosignalvariancehe[0][jeta][jphi] > 0.)
3221         recosignalvariancehe[0][jeta][jphi] /= (sumrecosignalHE0 / nsumrecosignalHE0);
3222       if (recosignalvariancehe[1][jeta][jphi] > 0.)
3223         recosignalvariancehe[1][jeta][jphi] /= (sumrecosignalHE1 / nsumrecosignalHE1);
3224       if (recosignalvariancehe[2][jeta][jphi] > 0.)
3225         recosignalvariancehe[2][jeta][jphi] /= (sumrecosignalHE2 / nsumrecosignalHE2);
3226       if (recosignalvariancehe[3][jeta][jphi] > 0.)
3227         recosignalvariancehe[3][jeta][jphi] /= (sumrecosignalHE3 / nsumrecosignalHE3);
3228       if (recosignalvariancehe[4][jeta][jphi] > 0.)
3229         recosignalvariancehe[4][jeta][jphi] /= (sumrecosignalHE4 / nsumrecosignalHE4);
3230       if (recosignalvariancehe[5][jeta][jphi] > 0.)
3231         recosignalvariancehe[5][jeta][jphi] /= (sumrecosignalHE5 / nsumrecosignalHE5);
3232       if (recosignalvariancehe[6][jeta][jphi] > 0.)
3233         recosignalvariancehe[6][jeta][jphi] /= (sumrecosignalHE6 / nsumrecosignalHE6);
3234     }  // phi
3235     //       recosignalvariancehe (D)           = sum(R*R)/N - (sum(R)/N)**2
3236     for (int jphi = 0; jphi < njphi; jphi++) {
3237       //       cout<<"12 12 12   jeta=     "<< jeta <<"   jphi   =     "<<jphi  <<endl;
3238       recosignalvariancehe[0][jeta][jphi] -= arecosignalhe[0][jeta][jphi] * arecosignalhe[0][jeta][jphi];
3239       recosignalvariancehe[0][jeta][jphi] = fabs(recosignalvariancehe[0][jeta][jphi]);
3240       recosignalvariancehe[1][jeta][jphi] -= arecosignalhe[1][jeta][jphi] * arecosignalhe[1][jeta][jphi];
3241       recosignalvariancehe[1][jeta][jphi] = fabs(recosignalvariancehe[1][jeta][jphi]);
3242       recosignalvariancehe[2][jeta][jphi] -= arecosignalhe[2][jeta][jphi] * arecosignalhe[2][jeta][jphi];
3243       recosignalvariancehe[2][jeta][jphi] = fabs(recosignalvariancehe[2][jeta][jphi]);
3244       recosignalvariancehe[3][jeta][jphi] -= arecosignalhe[3][jeta][jphi] * arecosignalhe[3][jeta][jphi];
3245       recosignalvariancehe[3][jeta][jphi] = fabs(recosignalvariancehe[3][jeta][jphi]);
3246       recosignalvariancehe[4][jeta][jphi] -= arecosignalhe[4][jeta][jphi] * arecosignalhe[4][jeta][jphi];
3247       recosignalvariancehe[4][jeta][jphi] = fabs(recosignalvariancehe[4][jeta][jphi]);
3248       recosignalvariancehe[5][jeta][jphi] -= arecosignalhe[5][jeta][jphi] * arecosignalhe[5][jeta][jphi];
3249       recosignalvariancehe[5][jeta][jphi] = fabs(recosignalvariancehe[5][jeta][jphi]);
3250       recosignalvariancehe[6][jeta][jphi] -= arecosignalhe[6][jeta][jphi] * arecosignalhe[6][jeta][jphi];
3251       recosignalvariancehe[6][jeta][jphi] = fabs(recosignalvariancehe[6][jeta][jphi]);
3252     }
3253   }
3254   //cout<<"      Vaiance: DONE*****" <<endl;
3255   //------------------------  2D-eta/phi-plot: D, averaged over depthes
3256   //======================================================================
3257   //======================================================================
3258   //cout<<"      R2D-eta/phi-plot: D, averaged over depthes *****" <<endl;
3259   c1x1->Clear();
3260   /////////////////
3261   c1x0->Divide(1, 1);
3262   c1x0->cd(1);
3263   TH2F* DefzDrecosignalHE42D = new TH2F("DefzDrecosignalHE42D", "", neta, -41., 41., nphi, 0., 72.);
3264   TH2F* DefzDrecosignalHE42D0 = new TH2F("DefzDrecosignalHE42D0", "", neta, -41., 41., nphi, 0., 72.);
3265   TH2F* DefzDrecosignalHE42DF = (TH2F*)DefzDrecosignalHE42D0->Clone("DefzDrecosignalHE42DF");
3266   for (int i = 0; i < ndepth; i++) {
3267     for (int jeta = 0; jeta < neta; jeta++) {
3268       for (int jphi = 0; jphi < nphi; jphi++) {
3269         double ccc1 = recosignalvariancehe[i][jeta][jphi];
3270         int k2plot = jeta - 41;
3271         int kkk = k2plot;  //if(k2plot >0   kkk=k2plot+1; //-41 +41 !=0
3272         if (arecosignalhe[i][jeta][jphi] > 0.) {
3273           DefzDrecosignalHE42D->Fill(kkk, jphi, ccc1);
3274           DefzDrecosignalHE42D0->Fill(kkk, jphi, 1.);
3275         }
3276       }
3277     }
3278   }
3279   DefzDrecosignalHE42DF->Divide(DefzDrecosignalHE42D, DefzDrecosignalHE42D0, 1, 1, "B");  // average A
3280   //    DefzDrecosignalHE1->Sumw2();
3281   gPad->SetGridy();
3282   gPad->SetGridx();  //      gPad->SetLogz();
3283   DefzDrecosignalHE42DF->SetMarkerStyle(20);
3284   DefzDrecosignalHE42DF->SetMarkerSize(0.4);
3285   DefzDrecosignalHE42DF->GetZaxis()->SetLabelSize(0.08);
3286   DefzDrecosignalHE42DF->SetXTitle("<D>_depth       #eta  \b");
3287   DefzDrecosignalHE42DF->SetYTitle("      #phi \b");
3288   DefzDrecosignalHE42DF->SetZTitle("<D>_depth \b");
3289   DefzDrecosignalHE42DF->SetMarkerColor(2);
3290   DefzDrecosignalHE42DF->SetLineColor(
3291       0);  //      DefzDrecosignalHE42DF->SetMaximum(1.000);  //      DefzDrecosignalHE42DF->SetMinimum(1.0);
3292   DefzDrecosignalHE42DF->Draw("COLZ");
3293   /////////////////
3294   c1x0->Update();
3295   c1x0->Print("DrecosignalGeneralD2PhiSymmetryHE.png");
3296   c1x0->Clear();
3297   // clean-up
3298   if (DefzDrecosignalHE42D)
3299     delete DefzDrecosignalHE42D;
3300   if (DefzDrecosignalHE42D0)
3301     delete DefzDrecosignalHE42D0;
3302   if (DefzDrecosignalHE42DF)
3303     delete DefzDrecosignalHE42DF;
3304   //====================================================================== 1D plot: D vs phi , averaged over depthes & eta
3305   //======================================================================
3306   //cout<<"      1D plot: D vs phi , averaged over depthes & eta *****" <<endl;
3307   c1x1->Clear();
3308   /////////////////
3309   c1x1->Divide(1, 1);
3310   c1x1->cd(1);
3311   TH1F* DefzDrecosignalHE41D = new TH1F("DefzDrecosignalHE41D", "", nphi, 0., 72.);
3312   TH1F* DefzDrecosignalHE41D0 = new TH1F("DefzDrecosignalHE41D0", "", nphi, 0., 72.);
3313   TH1F* DefzDrecosignalHE41DF = (TH1F*)DefzDrecosignalHE41D0->Clone("DefzDrecosignalHE41DF");
3314 
3315   for (int jphi = 0; jphi < nphi; jphi++) {
3316     for (int jeta = 0; jeta < neta; jeta++) {
3317       for (int i = 0; i < ndepth; i++) {
3318         double ccc1 = recosignalvariancehe[i][jeta][jphi];
3319         if (arecosignalhe[i][jeta][jphi] > 0.) {
3320           DefzDrecosignalHE41D->Fill(jphi, ccc1);
3321           DefzDrecosignalHE41D0->Fill(jphi, 1.);
3322         }
3323       }
3324     }
3325   }
3326   //     DefzDrecosignalHE41D->Sumw2();DefzDrecosignalHE41D0->Sumw2();
3327 
3328   DefzDrecosignalHE41DF->Divide(
3329       DefzDrecosignalHE41D, DefzDrecosignalHE41D0, 1, 1, "B");  // R averaged over depthes & eta
3330   DefzDrecosignalHE41D0->Sumw2();
3331   //    for (int jphi=1;jphi<73;jphi++) {DefzDrecosignalHE41DF->SetBinError(jphi,0.01);}
3332   gPad->SetGridy();
3333   gPad->SetGridx();  //      gPad->SetLogz();
3334   DefzDrecosignalHE41DF->SetMarkerStyle(20);
3335   DefzDrecosignalHE41DF->SetMarkerSize(1.4);
3336   DefzDrecosignalHE41DF->GetZaxis()->SetLabelSize(0.08);
3337   DefzDrecosignalHE41DF->SetXTitle("#phi  \b");
3338   DefzDrecosignalHE41DF->SetYTitle("  <D> \b");
3339   DefzDrecosignalHE41DF->SetZTitle("<D>_PHI  - AllDepthes \b");
3340   DefzDrecosignalHE41DF->SetMarkerColor(4);
3341   DefzDrecosignalHE41DF->SetLineColor(
3342       4);  // DefzDrecosignalHE41DF->SetMinimum(0.8);     DefzDrecosignalHE41DF->SetMinimum(-0.015);
3343   DefzDrecosignalHE41DF->Draw("Error");
3344   /////////////////
3345   c1x1->Update();
3346   c1x1->Print("DrecosignalGeneralD1PhiSymmetryHE.png");
3347   c1x1->Clear();
3348   // clean-up
3349   if (DefzDrecosignalHE41D)
3350     delete DefzDrecosignalHE41D;
3351   if (DefzDrecosignalHE41D0)
3352     delete DefzDrecosignalHE41D0;
3353   if (DefzDrecosignalHE41DF)
3354     delete DefzDrecosignalHE41DF;
3355   //========================================================================================== 14
3356   //======================================================================
3357   //======================================================================1D plot: D vs phi , different eta,  depth=1
3358   //cout<<"      1D plot: D vs phi , different eta,  depth=1 *****" <<endl;
3359   c3x5->Clear();
3360   /////////////////
3361   c3x5->Divide(3, 5);
3362   c3x5->cd(1);
3363   int kcountHEpositivedirectionRecosignalD1 = 1;
3364   TH1F* h2CeffHEpositivedirectionRecosignalD1 = new TH1F("h2CeffHEpositivedirectionRecosignalD1", "", nphi, 0., 72.);
3365 
3366   for (int jeta = 0; jeta < njeta; jeta++) {
3367     // positivedirectionRecosignalD:
3368     if (jeta - 41 >= 0) {
3369       //         for (int i=0;i<ndepth;i++) {
3370       // depth=1
3371       for (int i = 0; i < 1; i++) {
3372         TH1F* HEpositivedirectionRecosignalD1 = (TH1F*)h2CeffHEpositivedirectionRecosignalD1->Clone("twod1");
3373 
3374         float ccctest = 0;  // to avoid empty massive elements
3375         for (int jphi = 0; jphi < nphi; jphi++) {
3376           double ccc1 = recosignalvariancehe[i][jeta][jphi];
3377           if (arecosignalhe[i][jeta][jphi] > 0.) {
3378             HEpositivedirectionRecosignalD1->Fill(jphi, ccc1);
3379             ccctest = 1.;  //HEpositivedirectionRecosignalD1->SetBinError(i,0.01);
3380           }
3381         }  // for jphi
3382         if (ccctest > 0.) {
3383           //cout<<"1414       kcountHEpositivedirectionRecosignalD1   =     "<<kcountHEpositivedirectionRecosignalD1  <<"   jeta-41=     "<< jeta-41 <<endl;
3384           c3x5->cd(kcountHEpositivedirectionRecosignalD1);
3385           HEpositivedirectionRecosignalD1->SetMarkerStyle(20);
3386           HEpositivedirectionRecosignalD1->SetMarkerSize(0.4);
3387           HEpositivedirectionRecosignalD1->GetYaxis()->SetLabelSize(0.04);
3388           HEpositivedirectionRecosignalD1->SetXTitle("HEpositivedirectionRecosignalD1 \b");
3389           HEpositivedirectionRecosignalD1->SetMarkerColor(2);
3390           HEpositivedirectionRecosignalD1->SetLineColor(0);
3391           gPad->SetGridy();
3392           gPad->SetGridx();
3393           //       gPad->SetLogy();
3394           if (kcountHEpositivedirectionRecosignalD1 == 1)
3395             HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 17; depth = 1 \b");
3396           if (kcountHEpositivedirectionRecosignalD1 == 2)
3397             HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 18; depth = 1 \b");
3398           if (kcountHEpositivedirectionRecosignalD1 == 3)
3399             HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 19; depth = 1 \b");
3400           if (kcountHEpositivedirectionRecosignalD1 == 4)
3401             HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 20; depth = 1 \b");
3402           if (kcountHEpositivedirectionRecosignalD1 == 5)
3403             HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 21; depth = 1 \b");
3404           if (kcountHEpositivedirectionRecosignalD1 == 6)
3405             HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 22; depth = 1 \b");
3406           if (kcountHEpositivedirectionRecosignalD1 == 7)
3407             HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 23; depth = 1 \b");
3408           if (kcountHEpositivedirectionRecosignalD1 == 8)
3409             HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 24; depth = 1 \b");
3410           if (kcountHEpositivedirectionRecosignalD1 == 9)
3411             HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 25; depth = 1 \b");
3412           if (kcountHEpositivedirectionRecosignalD1 == 10)
3413             HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 26; depth = 1 \b");
3414           if (kcountHEpositivedirectionRecosignalD1 == 11)
3415             HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 27; depth = 1 \b");
3416           if (kcountHEpositivedirectionRecosignalD1 == 12)
3417             HEpositivedirectionRecosignalD1->SetXTitle("D for HE+ jeta = 28; depth = 1 \b");
3418           HEpositivedirectionRecosignalD1->Draw("Error");
3419           kcountHEpositivedirectionRecosignalD1++;
3420           if (kcountHEpositivedirectionRecosignalD1 > 12)
3421             break;  // 4x6 = 24
3422         }           //ccctest>0
3423 
3424       }  // for i
3425     }    //if(jeta-41 >= 0)
3426   }      //for jeta
3427   /////////////////
3428   c3x5->Update();
3429   c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth1HE.png");
3430   c3x5->Clear();
3431   // clean-up
3432   if (h2CeffHEpositivedirectionRecosignalD1)
3433     delete h2CeffHEpositivedirectionRecosignalD1;
3434   //========================================================================================== 15
3435   //======================================================================
3436   //======================================================================1D plot: D vs phi , different eta,  depth=2
3437   //cout<<"      1D plot: D vs phi , different eta,  depth=2 *****" <<endl;
3438   c3x5->Clear();
3439   c3x5->Divide(3, 5);
3440   c3x5->cd(1);
3441   int kcountHEpositivedirectionRecosignalD2 = 1;
3442   TH1F* h2CeffHEpositivedirectionRecosignalD2 = new TH1F("h2CeffHEpositivedirectionRecosignalD2", "", nphi, 0., 72.);
3443 
3444   for (int jeta = 0; jeta < njeta; jeta++) {
3445     // positivedirectionRecosignalD:
3446     if (jeta - 41 >= 0) {
3447       //         for (int i=0;i<ndepth;i++) {
3448       // depth=2
3449       for (int i = 1; i < 2; i++) {
3450         TH1F* HEpositivedirectionRecosignalD2 = (TH1F*)h2CeffHEpositivedirectionRecosignalD2->Clone("twod1");
3451 
3452         float ccctest = 0;  // to avoid empty massive elements
3453         for (int jphi = 0; jphi < nphi; jphi++) {
3454           double ccc1 = recosignalvariancehe[i][jeta][jphi];
3455           if (arecosignalhe[i][jeta][jphi] > 0.) {
3456             HEpositivedirectionRecosignalD2->Fill(jphi, ccc1);
3457             ccctest = 1.;  //HEpositivedirectionRecosignalD2->SetBinError(i,0.01);
3458           }
3459         }  // for jphi
3460         if (ccctest > 0.) {
3461           //cout<<"1515       kcountHEpositivedirectionRecosignalD2   =     "<<kcountHEpositivedirectionRecosignalD2  <<"   jeta-41=     "<< jeta-41 <<endl;
3462           c3x5->cd(kcountHEpositivedirectionRecosignalD2);
3463           HEpositivedirectionRecosignalD2->SetMarkerStyle(20);
3464           HEpositivedirectionRecosignalD2->SetMarkerSize(0.4);
3465           HEpositivedirectionRecosignalD2->GetYaxis()->SetLabelSize(0.04);
3466           HEpositivedirectionRecosignalD2->SetXTitle("HEpositivedirectionRecosignalD2 \b");
3467           HEpositivedirectionRecosignalD2->SetMarkerColor(2);
3468           HEpositivedirectionRecosignalD2->SetLineColor(0);
3469           gPad->SetGridy();
3470           gPad->SetGridx();
3471           //       gPad->SetLogy();
3472           if (kcountHEpositivedirectionRecosignalD2 == 1)
3473             HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 16; depth = 2 \b");
3474           if (kcountHEpositivedirectionRecosignalD2 == 2)
3475             HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 17; depth = 2 \b");
3476           if (kcountHEpositivedirectionRecosignalD2 == 3)
3477             HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 18; depth = 2 \b");
3478           if (kcountHEpositivedirectionRecosignalD2 == 4)
3479             HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 19; depth = 2 \b");
3480           if (kcountHEpositivedirectionRecosignalD2 == 5)
3481             HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 20; depth = 2 \b");
3482           if (kcountHEpositivedirectionRecosignalD2 == 6)
3483             HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 21; depth = 2 \b");
3484           if (kcountHEpositivedirectionRecosignalD2 == 7)
3485             HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 22; depth = 2 \b");
3486           if (kcountHEpositivedirectionRecosignalD2 == 8)
3487             HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 23; depth = 2 \b");
3488           if (kcountHEpositivedirectionRecosignalD2 == 9)
3489             HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 24; depth = 2 \b");
3490           if (kcountHEpositivedirectionRecosignalD2 == 10)
3491             HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 25; depth = 2 \b");
3492           if (kcountHEpositivedirectionRecosignalD2 == 11)
3493             HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 26; depth = 2 \b");
3494           if (kcountHEpositivedirectionRecosignalD2 == 12)
3495             HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 27; depth = 2 \b");
3496           if (kcountHEpositivedirectionRecosignalD2 == 13)
3497             HEpositivedirectionRecosignalD2->SetXTitle("D for HE+ jeta = 28; depth = 2 \b");
3498           HEpositivedirectionRecosignalD2->Draw("Error");
3499           kcountHEpositivedirectionRecosignalD2++;
3500           if (kcountHEpositivedirectionRecosignalD2 > 13)
3501             break;  // 4x6 = 24
3502         }           //ccctest>0
3503 
3504       }  // for i
3505     }    //if(jeta-41 >= 0)
3506   }      //for jeta
3507   /////////////////
3508   c3x5->Update();
3509   c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth2HE.png");
3510   c3x5->Clear();
3511   // clean-up
3512   if (h2CeffHEpositivedirectionRecosignalD2)
3513     delete h2CeffHEpositivedirectionRecosignalD2;
3514   //========================================================================================== 16
3515   //======================================================================
3516   //======================================================================1D plot: D vs phi , different eta,  depth=3
3517   //cout<<"      1D plot: D vs phi , different eta,  depth=3 *****" <<endl;
3518   c3x5->Clear();
3519   c3x5->Divide(3, 5);
3520   c3x5->cd(1);
3521   int kcountHEpositivedirectionRecosignalD3 = 1;
3522   TH1F* h2CeffHEpositivedirectionRecosignalD3 = new TH1F("h2CeffHEpositivedirectionRecosignalD3", "", nphi, 0., 72.);
3523 
3524   for (int jeta = 0; jeta < njeta; jeta++) {
3525     // positivedirectionRecosignalD:
3526     if (jeta - 41 >= 0) {
3527       //         for (int i=0;i<ndepth;i++) {
3528       // depth=3
3529       for (int i = 2; i < 3; i++) {
3530         TH1F* HEpositivedirectionRecosignalD3 = (TH1F*)h2CeffHEpositivedirectionRecosignalD3->Clone("twod1");
3531 
3532         float ccctest = 0;  // to avoid empty massive elements
3533         for (int jphi = 0; jphi < nphi; jphi++) {
3534           double ccc1 = recosignalvariancehe[i][jeta][jphi];
3535           if (arecosignalhe[i][jeta][jphi] > 0.) {
3536             HEpositivedirectionRecosignalD3->Fill(jphi, ccc1);
3537             ccctest = 1.;  //HEpositivedirectionRecosignalD3->SetBinError(i,0.01);
3538           }
3539         }  // for jphi
3540         if (ccctest > 0.) {
3541           //cout<<"1616       kcountHEpositivedirectionRecosignalD3   =     "<<kcountHEpositivedirectionRecosignalD3  <<"   jeta-41=     "<< jeta-41 <<endl;
3542           c3x5->cd(kcountHEpositivedirectionRecosignalD3);
3543           HEpositivedirectionRecosignalD3->SetMarkerStyle(20);
3544           HEpositivedirectionRecosignalD3->SetMarkerSize(0.4);
3545           HEpositivedirectionRecosignalD3->GetYaxis()->SetLabelSize(0.04);
3546           HEpositivedirectionRecosignalD3->SetXTitle("HEpositivedirectionRecosignalD3 \b");
3547           HEpositivedirectionRecosignalD3->SetMarkerColor(2);
3548           HEpositivedirectionRecosignalD3->SetLineColor(0);
3549           gPad->SetGridy();
3550           gPad->SetGridx();
3551           //       gPad->SetLogy();
3552           if (kcountHEpositivedirectionRecosignalD3 == 1)
3553             HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 16; depth = 3 \b");
3554           if (kcountHEpositivedirectionRecosignalD3 == 2)
3555             HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 17; depth = 3 \b");
3556           if (kcountHEpositivedirectionRecosignalD3 == 3)
3557             HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 18; depth = 3 \b");
3558           if (kcountHEpositivedirectionRecosignalD3 == 4)
3559             HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 19; depth = 3 \b");
3560           if (kcountHEpositivedirectionRecosignalD3 == 5)
3561             HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 20; depth = 3 \b");
3562           if (kcountHEpositivedirectionRecosignalD3 == 6)
3563             HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 21; depth = 3 \b");
3564           if (kcountHEpositivedirectionRecosignalD3 == 7)
3565             HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 22; depth = 3 \b");
3566           if (kcountHEpositivedirectionRecosignalD3 == 8)
3567             HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 23; depth = 3 \b");
3568           if (kcountHEpositivedirectionRecosignalD3 == 9)
3569             HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 24; depth = 3 \b");
3570           if (kcountHEpositivedirectionRecosignalD3 == 10)
3571             HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 25; depth = 3 \b");
3572           if (kcountHEpositivedirectionRecosignalD3 == 11)
3573             HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 26; depth = 3 \b");
3574           if (kcountHEpositivedirectionRecosignalD3 == 12)
3575             HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 27; depth = 3 \b");
3576           if (kcountHEpositivedirectionRecosignalD3 == 13)
3577             HEpositivedirectionRecosignalD3->SetXTitle("D for HE+ jeta = 28; depth = 3 \b");
3578           HEpositivedirectionRecosignalD3->Draw("Error");
3579           kcountHEpositivedirectionRecosignalD3++;
3580           if (kcountHEpositivedirectionRecosignalD3 > 13)
3581             break;  // 4x6 = 24
3582         }           //ccctest>0
3583 
3584       }  // for i
3585     }    //if(jeta-41 >= 0)
3586   }      //for jeta
3587   /////////////////
3588   c3x5->Update();
3589   c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth3HE.png");
3590   c3x5->Clear();
3591   // clean-up
3592   if (h2CeffHEpositivedirectionRecosignalD3)
3593     delete h2CeffHEpositivedirectionRecosignalD3;
3594   //========================================================================================== 17
3595   //======================================================================
3596   //======================================================================1D plot: D vs phi , different eta,  depth=4
3597   //cout<<"      1D plot: D vs phi , different eta,  depth=4 *****" <<endl;
3598   c3x5->Clear();
3599   c3x5->Divide(3, 5);
3600   c3x5->cd(1);
3601   int kcountHEpositivedirectionRecosignalD4 = 1;
3602   TH1F* h2CeffHEpositivedirectionRecosignalD4 = new TH1F("h2CeffHEpositivedirectionRecosignalD4", "", nphi, 0., 72.);
3603 
3604   for (int jeta = 0; jeta < njeta; jeta++) {
3605     // positivedirectionRecosignalD:
3606     if (jeta - 41 >= 0) {
3607       //         for (int i=0;i<ndepth;i++) {
3608       // depth=4
3609       for (int i = 3; i < 4; i++) {
3610         TH1F* HEpositivedirectionRecosignalD4 = (TH1F*)h2CeffHEpositivedirectionRecosignalD4->Clone("twod1");
3611 
3612         float ccctest = 0;  // to avoid empty massive elements
3613         for (int jphi = 0; jphi < nphi; jphi++) {
3614           double ccc1 = recosignalvariancehe[i][jeta][jphi];
3615           if (arecosignalhe[i][jeta][jphi] > 0.) {
3616             HEpositivedirectionRecosignalD4->Fill(jphi, ccc1);
3617             ccctest = 1.;  //HEpositivedirectionRecosignalD4->SetBinError(i,0.01);
3618           }
3619         }  // for jphi
3620         if (ccctest > 0.) {
3621           //cout<<"1717       kcountHEpositivedirectionRecosignalD4   =     "<<kcountHEpositivedirectionRecosignalD4  <<"   jeta-41=     "<< jeta-41 <<endl;
3622           c3x5->cd(kcountHEpositivedirectionRecosignalD4);
3623           HEpositivedirectionRecosignalD4->SetMarkerStyle(20);
3624           HEpositivedirectionRecosignalD4->SetMarkerSize(0.4);
3625           HEpositivedirectionRecosignalD4->GetYaxis()->SetLabelSize(0.04);
3626           HEpositivedirectionRecosignalD4->SetXTitle("HEpositivedirectionRecosignalD4 \b");
3627           HEpositivedirectionRecosignalD4->SetMarkerColor(2);
3628           HEpositivedirectionRecosignalD4->SetLineColor(0);
3629           gPad->SetGridy();
3630           gPad->SetGridx();
3631           //       gPad->SetLogy();
3632           if (kcountHEpositivedirectionRecosignalD4 == 1)
3633             HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 15; depth = 4 \b");
3634           if (kcountHEpositivedirectionRecosignalD4 == 2)
3635             HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 17; depth = 4 \b");
3636           if (kcountHEpositivedirectionRecosignalD4 == 3)
3637             HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 18; depth = 4 \b");
3638           if (kcountHEpositivedirectionRecosignalD4 == 4)
3639             HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 19; depth = 4 \b");
3640           if (kcountHEpositivedirectionRecosignalD4 == 5)
3641             HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 20; depth = 4 \b");
3642           if (kcountHEpositivedirectionRecosignalD4 == 6)
3643             HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 21; depth = 4 \b");
3644           if (kcountHEpositivedirectionRecosignalD4 == 7)
3645             HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 22; depth = 4 \b");
3646           if (kcountHEpositivedirectionRecosignalD4 == 8)
3647             HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 23; depth = 4 \b");
3648           if (kcountHEpositivedirectionRecosignalD4 == 9)
3649             HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 24; depth = 4 \b");
3650           if (kcountHEpositivedirectionRecosignalD4 == 10)
3651             HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 25; depth = 4 \b");
3652           if (kcountHEpositivedirectionRecosignalD4 == 11)
3653             HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 26; depth = 4 \b");
3654           if (kcountHEpositivedirectionRecosignalD4 == 12)
3655             HEpositivedirectionRecosignalD4->SetXTitle("D for HE+ jeta = 27; depth = 4 \b");
3656           HEpositivedirectionRecosignalD4->Draw("Error");
3657           kcountHEpositivedirectionRecosignalD4++;
3658           if (kcountHEpositivedirectionRecosignalD4 > 12)
3659             break;  // 4x6 = 24
3660         }           //ccctest>0
3661 
3662       }  // for i
3663     }    //if(jeta-41 >= 0)
3664   }      //for jeta
3665   /////////////////
3666   c3x5->Update();
3667   c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth4HE.png");
3668   c3x5->Clear();
3669   // clean-up
3670   if (h2CeffHEpositivedirectionRecosignalD4)
3671     delete h2CeffHEpositivedirectionRecosignalD4;
3672   //========================================================================================== 18
3673   //======================================================================
3674   //======================================================================1D plot: D vs phi , different eta,  depth=5
3675   //cout<<"      1D plot: D vs phi , different eta,  depth=5 *****" <<endl;
3676   c3x5->Clear();
3677   c3x5->Divide(3, 5);
3678   c3x5->cd(1);
3679   int kcountHEpositivedirectionRecosignalD5 = 1;
3680   TH1F* h2CeffHEpositivedirectionRecosignalD5 = new TH1F("h2CeffHEpositivedirectionRecosignalD5", "", nphi, 0., 72.);
3681 
3682   for (int jeta = 0; jeta < njeta; jeta++) {
3683     // positivedirectionRecosignalD:
3684     if (jeta - 41 >= 0) {
3685       //         for (int i=0;i<ndepth;i++) {
3686       // depth=5
3687       for (int i = 4; i < 5; i++) {
3688         TH1F* HEpositivedirectionRecosignalD5 = (TH1F*)h2CeffHEpositivedirectionRecosignalD5->Clone("twod1");
3689 
3690         float ccctest = 0;  // to avoid empty massive elements
3691         for (int jphi = 0; jphi < nphi; jphi++) {
3692           double ccc1 = recosignalvariancehe[i][jeta][jphi];
3693           if (arecosignalhe[i][jeta][jphi] > 0.) {
3694             HEpositivedirectionRecosignalD5->Fill(jphi, ccc1);
3695             ccctest = 1.;  //HEpositivedirectionRecosignalD5->SetBinError(i,0.01);
3696           }
3697         }  // for jphi
3698         if (ccctest > 0.) {
3699           //cout<<"1818       kcountHEpositivedirectionRecosignalD5   =     "<<kcountHEpositivedirectionRecosignalD5  <<"   jeta-41=     "<< jeta-41 <<endl;
3700           c3x5->cd(kcountHEpositivedirectionRecosignalD5);
3701           HEpositivedirectionRecosignalD5->SetMarkerStyle(20);
3702           HEpositivedirectionRecosignalD5->SetMarkerSize(0.4);
3703           HEpositivedirectionRecosignalD5->GetYaxis()->SetLabelSize(0.04);
3704           HEpositivedirectionRecosignalD5->SetXTitle("HEpositivedirectionRecosignalD5 \b");
3705           HEpositivedirectionRecosignalD5->SetMarkerColor(2);
3706           HEpositivedirectionRecosignalD5->SetLineColor(0);
3707           gPad->SetGridy();
3708           gPad->SetGridx();
3709           //       gPad->SetLogy();
3710           if (kcountHEpositivedirectionRecosignalD5 == 1)
3711             HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 17; depth = 5 \b");
3712           if (kcountHEpositivedirectionRecosignalD5 == 2)
3713             HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 18; depth = 5 \b");
3714           if (kcountHEpositivedirectionRecosignalD5 == 3)
3715             HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 19; depth = 5 \b");
3716           if (kcountHEpositivedirectionRecosignalD5 == 4)
3717             HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 20; depth = 5 \b");
3718           if (kcountHEpositivedirectionRecosignalD5 == 5)
3719             HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 21; depth = 5 \b");
3720           if (kcountHEpositivedirectionRecosignalD5 == 6)
3721             HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 22; depth = 5 \b");
3722           if (kcountHEpositivedirectionRecosignalD5 == 7)
3723             HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 23; depth = 5 \b");
3724           if (kcountHEpositivedirectionRecosignalD5 == 8)
3725             HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 24; depth = 5 \b");
3726           if (kcountHEpositivedirectionRecosignalD5 == 9)
3727             HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 25; depth = 5 \b");
3728           if (kcountHEpositivedirectionRecosignalD5 == 10)
3729             HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 26; depth = 5 \b");
3730           if (kcountHEpositivedirectionRecosignalD5 == 11)
3731             HEpositivedirectionRecosignalD5->SetXTitle("D for HE+ jeta = 27; depth = 5 \b");
3732           HEpositivedirectionRecosignalD5->Draw("Error");
3733           kcountHEpositivedirectionRecosignalD5++;
3734           if (kcountHEpositivedirectionRecosignalD5 > 11)
3735             break;  // 4x6 = 24
3736         }           //ccctest>0
3737 
3738       }  // for i
3739     }    //if(jeta-41 >= 0)
3740   }      //for jeta
3741   /////////////////
3742   c3x5->Update();
3743   c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth5HE.png");
3744   c3x5->Clear();
3745   // clean-up
3746   if (h2CeffHEpositivedirectionRecosignalD5)
3747     delete h2CeffHEpositivedirectionRecosignalD5;
3748   //========================================================================================== 19
3749   //======================================================================
3750   //======================================================================1D plot: D vs phi , different eta,  depth=6
3751   //cout<<"      1D plot: D vs phi , different eta,  depth=6 *****" <<endl;
3752   c3x5->Clear();
3753   c3x5->Divide(3, 5);
3754   c3x5->cd(1);
3755   int kcountHEpositivedirectionRecosignalD6 = 1;
3756   TH1F* h2CeffHEpositivedirectionRecosignalD6 = new TH1F("h2CeffHEpositivedirectionRecosignalD6", "", nphi, 0., 72.);
3757 
3758   for (int jeta = 0; jeta < njeta; jeta++) {
3759     // positivedirectionRecosignalD:
3760     if (jeta - 41 >= 0) {
3761       //         for (int i=0;i<ndepth;i++) {
3762       // depth=6
3763       for (int i = 5; i < 6; i++) {
3764         TH1F* HEpositivedirectionRecosignalD6 = (TH1F*)h2CeffHEpositivedirectionRecosignalD6->Clone("twod1");
3765 
3766         float ccctest = 0;  // to avoid empty massive elements
3767         for (int jphi = 0; jphi < nphi; jphi++) {
3768           double ccc1 = recosignalvariancehe[i][jeta][jphi];
3769           if (arecosignalhe[i][jeta][jphi] > 0.) {
3770             HEpositivedirectionRecosignalD6->Fill(jphi, ccc1);
3771             ccctest = 1.;  //HEpositivedirectionRecosignalD6->SetBinError(i,0.01);
3772           }
3773         }  // for jphi
3774         if (ccctest > 0.) {
3775           //cout<<"1919       kcountHEpositivedirectionRecosignalD6   =     "<<kcountHEpositivedirectionRecosignalD6  <<"   jeta-41=     "<< jeta-41 <<endl;
3776           c3x5->cd(kcountHEpositivedirectionRecosignalD6);
3777           HEpositivedirectionRecosignalD6->SetMarkerStyle(20);
3778           HEpositivedirectionRecosignalD6->SetMarkerSize(0.4);
3779           HEpositivedirectionRecosignalD6->GetYaxis()->SetLabelSize(0.04);
3780           HEpositivedirectionRecosignalD6->SetXTitle("HEpositivedirectionRecosignalD6 \b");
3781           HEpositivedirectionRecosignalD6->SetMarkerColor(2);
3782           HEpositivedirectionRecosignalD6->SetLineColor(0);
3783           gPad->SetGridy();
3784           gPad->SetGridx();
3785           //       gPad->SetLogy();
3786           if (kcountHEpositivedirectionRecosignalD6 == 1)
3787             HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 18; depth = 6 \b");
3788           if (kcountHEpositivedirectionRecosignalD6 == 2)
3789             HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 19; depth = 6 \b");
3790           if (kcountHEpositivedirectionRecosignalD6 == 3)
3791             HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 20; depth = 6 \b");
3792           if (kcountHEpositivedirectionRecosignalD6 == 4)
3793             HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 21; depth = 6 \b");
3794           if (kcountHEpositivedirectionRecosignalD6 == 5)
3795             HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 22; depth = 6 \b");
3796           if (kcountHEpositivedirectionRecosignalD6 == 6)
3797             HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 23; depth = 6 \b");
3798           if (kcountHEpositivedirectionRecosignalD6 == 7)
3799             HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 24; depth = 6 \b");
3800           if (kcountHEpositivedirectionRecosignalD6 == 8)
3801             HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 25; depth = 6 \b");
3802           if (kcountHEpositivedirectionRecosignalD6 == 9)
3803             HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 26; depth = 6 \b");
3804           if (kcountHEpositivedirectionRecosignalD6 == 10)
3805             HEpositivedirectionRecosignalD6->SetXTitle("D for HE+ jeta = 27; depth = 6 \b");
3806           HEpositivedirectionRecosignalD6->Draw("Error");
3807           kcountHEpositivedirectionRecosignalD6++;
3808           if (kcountHEpositivedirectionRecosignalD6 > 10)
3809             break;  // 4x6 = 24
3810         }           //ccctest>0
3811 
3812       }  // for i
3813     }    //if(jeta-41 >= 0)
3814   }      //for jeta
3815   /////////////////
3816   c3x5->Update();
3817   c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth6HE.png");
3818   c3x5->Clear();
3819   // clean-up
3820   if (h2CeffHEpositivedirectionRecosignalD6)
3821     delete h2CeffHEpositivedirectionRecosignalD6;
3822   //========================================================================================== 20
3823   //======================================================================
3824   //======================================================================1D plot: D vs phi , different eta,  depth=7
3825   //cout<<"      1D plot: D vs phi , different eta,  depth=7 *****" <<endl;
3826   c3x5->Clear();
3827   c3x5->Divide(3, 5);
3828   c3x5->cd(1);
3829   int kcountHEpositivedirectionRecosignalD7 = 1;
3830   TH1F* h2CeffHEpositivedirectionRecosignalD7 = new TH1F("h2CeffHEpositivedirectionRecosignalD7", "", nphi, 0., 72.);
3831 
3832   for (int jeta = 0; jeta < njeta; jeta++) {
3833     // positivedirectionRecosignalD:
3834     if (jeta - 41 >= 0) {
3835       //         for (int i=0;i<ndepth;i++) {
3836       // depth=7
3837       for (int i = 6; i < 7; i++) {
3838         TH1F* HEpositivedirectionRecosignalD7 = (TH1F*)h2CeffHEpositivedirectionRecosignalD7->Clone("twod1");
3839 
3840         float ccctest = 0;  // to avoid empty massive elements
3841         for (int jphi = 0; jphi < nphi; jphi++) {
3842           double ccc1 = recosignalvariancehe[i][jeta][jphi];
3843           if (arecosignalhe[i][jeta][jphi] > 0.) {
3844             HEpositivedirectionRecosignalD7->Fill(jphi, ccc1);
3845             ccctest = 1.;  //HEpositivedirectionRecosignalD7->SetBinError(i,0.01);
3846           }
3847         }  // for jphi
3848         if (ccctest != 0.) {
3849           //cout<<"2020       kcountHEpositivedirectionRecosignalD7   =     "<<kcountHEpositivedirectionRecosignalD7  <<"   jeta-41=     "<< jeta-41 <<endl;
3850           c3x5->cd(kcountHEpositivedirectionRecosignalD7);
3851           HEpositivedirectionRecosignalD7->SetMarkerStyle(20);
3852           HEpositivedirectionRecosignalD7->SetMarkerSize(0.4);
3853           HEpositivedirectionRecosignalD7->GetYaxis()->SetLabelSize(0.04);
3854           HEpositivedirectionRecosignalD7->SetXTitle("HEpositivedirectionRecosignalD7 \b");
3855           HEpositivedirectionRecosignalD7->SetMarkerColor(2);
3856           HEpositivedirectionRecosignalD7->SetLineColor(0);
3857           gPad->SetGridy();
3858           gPad->SetGridx();
3859           //       gPad->SetLogy();
3860           if (kcountHEpositivedirectionRecosignalD7 == 1)
3861             HEpositivedirectionRecosignalD7->SetXTitle("D for HE+ jeta = 25; depth = 7 \b");
3862           if (kcountHEpositivedirectionRecosignalD7 == 2)
3863             HEpositivedirectionRecosignalD7->SetXTitle("D for HE+ jeta = 26; depth = 7 \b");
3864           if (kcountHEpositivedirectionRecosignalD7 == 3)
3865             HEpositivedirectionRecosignalD7->SetXTitle("D for HE+ jeta = 27; depth = 7 \b");
3866           HEpositivedirectionRecosignalD7->Draw("Error");
3867           kcountHEpositivedirectionRecosignalD7++;
3868           if (kcountHEpositivedirectionRecosignalD7 > 3)
3869             break;  // 4x6 = 24
3870         }           //ccctest>0
3871 
3872       }  // for i
3873     }    //if(jeta-41 >= 0)
3874   }      //for jeta
3875   /////////////////
3876   c3x5->Update();
3877   c3x5->Print("DrecosignalPositiveDirectionhistD1PhiSymmetryDepth7HE.png");
3878   c3x5->Clear();
3879   // clean-up
3880   if (h2CeffHEpositivedirectionRecosignalD7)
3881     delete h2CeffHEpositivedirectionRecosignalD7;
3882 
3883   //========================================================================================== 22222214
3884   //======================================================================
3885   //======================================================================1D plot: D vs phi , different eta,  depth=1
3886   //cout<<"      1D plot: D vs phi , different eta,  depth=1 *****" <<endl;
3887   c3x5->Clear();
3888   /////////////////
3889   c3x5->Divide(3, 5);
3890   c3x5->cd(1);
3891   int kcountHEnegativedirectionRecosignalD1 = 1;
3892   TH1F* h2CeffHEnegativedirectionRecosignalD1 = new TH1F("h2CeffHEnegativedirectionRecosignalD1", "", nphi, 0., 72.);
3893 
3894   for (int jeta = 0; jeta < njeta; jeta++) {
3895     // negativedirectionRecosignalD:
3896     if (jeta - 41 < 0) {
3897       //         for (int i=0;i<ndepth;i++) {
3898       // depth=1
3899       for (int i = 0; i < 1; i++) {
3900         TH1F* HEnegativedirectionRecosignalD1 = (TH1F*)h2CeffHEnegativedirectionRecosignalD1->Clone("twod1");
3901 
3902         float ccctest = 0;  // to avoid empty massive elements
3903         for (int jphi = 0; jphi < nphi; jphi++) {
3904           double ccc1 = recosignalvariancehe[i][jeta][jphi];
3905           if (arecosignalhe[i][jeta][jphi] > 0.) {
3906             HEnegativedirectionRecosignalD1->Fill(jphi, ccc1);
3907             ccctest = 1.;  //HEnegativedirectionRecosignalD1->SetBinError(i,0.01);
3908           }
3909         }  // for jphi
3910         if (ccctest > 0.) {
3911           //cout<<"1414       kcountHEnegativedirectionRecosignalD1   =     "<<kcountHEnegativedirectionRecosignalD1  <<"   jeta-41=     "<< jeta-41 <<endl;
3912           c3x5->cd(kcountHEnegativedirectionRecosignalD1);
3913           HEnegativedirectionRecosignalD1->SetMarkerStyle(20);
3914           HEnegativedirectionRecosignalD1->SetMarkerSize(0.4);
3915           HEnegativedirectionRecosignalD1->GetYaxis()->SetLabelSize(0.04);
3916           HEnegativedirectionRecosignalD1->SetXTitle("HEnegativedirectionRecosignalD1 \b");
3917           HEnegativedirectionRecosignalD1->SetMarkerColor(2);
3918           HEnegativedirectionRecosignalD1->SetLineColor(0);
3919           gPad->SetGridy();
3920           gPad->SetGridx();
3921           //       gPad->SetLogy();
3922           if (kcountHEnegativedirectionRecosignalD1 == 1)
3923             HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-29; depth = 1 \b");
3924           if (kcountHEnegativedirectionRecosignalD1 == 2)
3925             HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-28; depth = 1 \b");
3926           if (kcountHEnegativedirectionRecosignalD1 == 3)
3927             HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-27; depth = 1 \b");
3928           if (kcountHEnegativedirectionRecosignalD1 == 4)
3929             HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-26; depth = 1 \b");
3930           if (kcountHEnegativedirectionRecosignalD1 == 5)
3931             HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-25; depth = 1 \b");
3932           if (kcountHEnegativedirectionRecosignalD1 == 6)
3933             HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-24; depth = 1 \b");
3934           if (kcountHEnegativedirectionRecosignalD1 == 7)
3935             HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-23; depth = 1 \b");
3936           if (kcountHEnegativedirectionRecosignalD1 == 8)
3937             HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-22; depth = 1 \b");
3938           if (kcountHEnegativedirectionRecosignalD1 == 9)
3939             HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-21; depth = 1 \b");
3940           if (kcountHEnegativedirectionRecosignalD1 == 10)
3941             HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-20; depth = 1 \b");
3942           if (kcountHEnegativedirectionRecosignalD1 == 11)
3943             HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-19; depth = 1 \b");
3944           if (kcountHEnegativedirectionRecosignalD1 == 12)
3945             HEnegativedirectionRecosignalD1->SetXTitle("D for HE- jeta =-18; depth = 1 \b");
3946           HEnegativedirectionRecosignalD1->Draw("Error");
3947           kcountHEnegativedirectionRecosignalD1++;
3948           if (kcountHEnegativedirectionRecosignalD1 > 12)
3949             break;  // 4x6 = 24
3950         }           //ccctest>0
3951 
3952       }  // for i
3953     }    //if(jeta-41 < 0)
3954   }      //for jeta
3955   /////////////////
3956   c3x5->Update();
3957   c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth1HE.png");
3958   c3x5->Clear();
3959   // clean-up
3960   if (h2CeffHEnegativedirectionRecosignalD1)
3961     delete h2CeffHEnegativedirectionRecosignalD1;
3962   //========================================================================================== 22222215
3963   //======================================================================
3964   //======================================================================1D plot: D vs phi , different eta,  depth=2
3965   //cout<<"      1D plot: D vs phi , different eta,  depth=2 *****" <<endl;
3966   c3x5->Clear();
3967   c3x5->Divide(3, 5);
3968   c3x5->cd(1);
3969   int kcountHEnegativedirectionRecosignalD2 = 1;
3970   TH1F* h2CeffHEnegativedirectionRecosignalD2 = new TH1F("h2CeffHEnegativedirectionRecosignalD2", "", nphi, 0., 72.);
3971 
3972   for (int jeta = 0; jeta < njeta; jeta++) {
3973     // negativedirectionRecosignalD:
3974     if (jeta - 41 < 0) {
3975       //         for (int i=0;i<ndepth;i++) {
3976       // depth=2
3977       for (int i = 1; i < 2; i++) {
3978         TH1F* HEnegativedirectionRecosignalD2 = (TH1F*)h2CeffHEnegativedirectionRecosignalD2->Clone("twod1");
3979 
3980         float ccctest = 0;  // to avoid empty massive elements
3981         for (int jphi = 0; jphi < nphi; jphi++) {
3982           double ccc1 = recosignalvariancehe[i][jeta][jphi];
3983           if (arecosignalhe[i][jeta][jphi] > 0.) {
3984             HEnegativedirectionRecosignalD2->Fill(jphi, ccc1);
3985             ccctest = 1.;  //HEnegativedirectionRecosignalD2->SetBinError(i,0.01);
3986           }
3987         }  // for jphi
3988         if (ccctest > 0.) {
3989           //cout<<"1515       kcountHEnegativedirectionRecosignalD2   =     "<<kcountHEnegativedirectionRecosignalD2  <<"   jeta-41=     "<< jeta-41 <<endl;
3990           c3x5->cd(kcountHEnegativedirectionRecosignalD2);
3991           HEnegativedirectionRecosignalD2->SetMarkerStyle(20);
3992           HEnegativedirectionRecosignalD2->SetMarkerSize(0.4);
3993           HEnegativedirectionRecosignalD2->GetYaxis()->SetLabelSize(0.04);
3994           HEnegativedirectionRecosignalD2->SetXTitle("HEnegativedirectionRecosignalD2 \b");
3995           HEnegativedirectionRecosignalD2->SetMarkerColor(2);
3996           HEnegativedirectionRecosignalD2->SetLineColor(0);
3997           gPad->SetGridy();
3998           gPad->SetGridx();
3999           //       gPad->SetLogy();
4000           if (kcountHEnegativedirectionRecosignalD2 == 1)
4001             HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-29; depth = 2 \b");
4002           if (kcountHEnegativedirectionRecosignalD2 == 2)
4003             HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-28; depth = 2 \b");
4004           if (kcountHEnegativedirectionRecosignalD2 == 3)
4005             HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-27; depth = 2 \b");
4006           if (kcountHEnegativedirectionRecosignalD2 == 4)
4007             HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-26; depth = 2 \b");
4008           if (kcountHEnegativedirectionRecosignalD2 == 5)
4009             HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-25; depth = 2 \b");
4010           if (kcountHEnegativedirectionRecosignalD2 == 6)
4011             HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-24; depth = 2 \b");
4012           if (kcountHEnegativedirectionRecosignalD2 == 7)
4013             HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-23; depth = 2 \b");
4014           if (kcountHEnegativedirectionRecosignalD2 == 8)
4015             HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-22; depth = 2 \b");
4016           if (kcountHEnegativedirectionRecosignalD2 == 9)
4017             HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-21; depth = 2 \b");
4018           if (kcountHEnegativedirectionRecosignalD2 == 10)
4019             HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-20; depth = 2 \b");
4020           if (kcountHEnegativedirectionRecosignalD2 == 11)
4021             HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-19; depth = 2 \b");
4022           if (kcountHEnegativedirectionRecosignalD2 == 12)
4023             HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-18; depth = 2 \b");
4024           if (kcountHEnegativedirectionRecosignalD2 == 13)
4025             HEnegativedirectionRecosignalD2->SetXTitle("D for HE- jeta =-17; depth = 2 \b");
4026           HEnegativedirectionRecosignalD2->Draw("Error");
4027           kcountHEnegativedirectionRecosignalD2++;
4028           if (kcountHEnegativedirectionRecosignalD2 > 13)
4029             break;  // 4x6 = 24
4030         }           //ccctest>0
4031 
4032       }  // for i
4033     }    //if(jeta-41 < 0)
4034   }      //for jeta
4035   /////////////////
4036   c3x5->Update();
4037   c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth2HE.png");
4038   c3x5->Clear();
4039   // clean-up
4040   if (h2CeffHEnegativedirectionRecosignalD2)
4041     delete h2CeffHEnegativedirectionRecosignalD2;
4042   //========================================================================================== 22222216
4043   //======================================================================
4044   //======================================================================1D plot: D vs phi , different eta,  depth=3
4045   //cout<<"      1D plot: D vs phi , different eta,  depth=3 *****" <<endl;
4046   c3x5->Clear();
4047   c3x5->Divide(3, 5);
4048   c3x5->cd(1);
4049   int kcountHEnegativedirectionRecosignalD3 = 1;
4050   TH1F* h2CeffHEnegativedirectionRecosignalD3 = new TH1F("h2CeffHEnegativedirectionRecosignalD3", "", nphi, 0., 72.);
4051 
4052   for (int jeta = 0; jeta < njeta; jeta++) {
4053     // negativedirectionRecosignalD:
4054     if (jeta - 41 < 0) {
4055       //         for (int i=0;i<ndepth;i++) {
4056       // depth=3
4057       for (int i = 2; i < 3; i++) {
4058         TH1F* HEnegativedirectionRecosignalD3 = (TH1F*)h2CeffHEnegativedirectionRecosignalD3->Clone("twod1");
4059 
4060         float ccctest = 0;  // to avoid empty massive elements
4061         for (int jphi = 0; jphi < nphi; jphi++) {
4062           double ccc1 = recosignalvariancehe[i][jeta][jphi];
4063           if (arecosignalhe[i][jeta][jphi] > 0.) {
4064             HEnegativedirectionRecosignalD3->Fill(jphi, ccc1);
4065             ccctest = 1.;  //HEnegativedirectionRecosignalD3->SetBinError(i,0.01);
4066           }
4067         }  // for jphi
4068         if (ccctest > 0.) {
4069           //cout<<"1616       kcountHEnegativedirectionRecosignalD3   =     "<<kcountHEnegativedirectionRecosignalD3  <<"   jeta-41=     "<< jeta-41 <<endl;
4070           c3x5->cd(kcountHEnegativedirectionRecosignalD3);
4071           HEnegativedirectionRecosignalD3->SetMarkerStyle(20);
4072           HEnegativedirectionRecosignalD3->SetMarkerSize(0.4);
4073           HEnegativedirectionRecosignalD3->GetYaxis()->SetLabelSize(0.04);
4074           HEnegativedirectionRecosignalD3->SetXTitle("HEnegativedirectionRecosignalD3 \b");
4075           HEnegativedirectionRecosignalD3->SetMarkerColor(2);
4076           HEnegativedirectionRecosignalD3->SetLineColor(0);
4077           gPad->SetGridy();
4078           gPad->SetGridx();
4079           //       gPad->SetLogy();
4080           if (kcountHEnegativedirectionRecosignalD3 == 1)
4081             HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-29; depth = 3 \b");
4082           if (kcountHEnegativedirectionRecosignalD3 == 2)
4083             HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-28; depth = 3 \b");
4084           if (kcountHEnegativedirectionRecosignalD3 == 3)
4085             HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-27; depth = 3 \b");
4086           if (kcountHEnegativedirectionRecosignalD3 == 4)
4087             HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-26; depth = 3 \b");
4088           if (kcountHEnegativedirectionRecosignalD3 == 5)
4089             HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-25; depth = 3 \b");
4090           if (kcountHEnegativedirectionRecosignalD3 == 6)
4091             HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-24; depth = 3 \b");
4092           if (kcountHEnegativedirectionRecosignalD3 == 7)
4093             HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-23; depth = 3 \b");
4094           if (kcountHEnegativedirectionRecosignalD3 == 8)
4095             HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-22; depth = 3 \b");
4096           if (kcountHEnegativedirectionRecosignalD3 == 9)
4097             HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-21; depth = 3 \b");
4098           if (kcountHEnegativedirectionRecosignalD3 == 10)
4099             HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-20; depth = 3 \b");
4100           if (kcountHEnegativedirectionRecosignalD3 == 11)
4101             HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-19; depth = 3 \b");
4102           if (kcountHEnegativedirectionRecosignalD3 == 12)
4103             HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-18; depth = 3 \b");
4104           if (kcountHEnegativedirectionRecosignalD3 == 13)
4105             HEnegativedirectionRecosignalD3->SetXTitle("D for HE- jeta =-17; depth = 3 \b");
4106           HEnegativedirectionRecosignalD3->Draw("Error");
4107           kcountHEnegativedirectionRecosignalD3++;
4108           if (kcountHEnegativedirectionRecosignalD3 > 13)
4109             break;  // 4x6 = 24
4110         }           //ccctest>0
4111 
4112       }  // for i
4113     }    //if(jeta-41 < 0)
4114   }      //for jeta
4115   /////////////////
4116   c3x5->Update();
4117   c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth3HE.png");
4118   c3x5->Clear();
4119   // clean-up
4120   if (h2CeffHEnegativedirectionRecosignalD3)
4121     delete h2CeffHEnegativedirectionRecosignalD3;
4122   //========================================================================================== 22222217
4123   //======================================================================
4124   //======================================================================1D plot: D vs phi , different eta,  depth=4
4125   //cout<<"      1D plot: D vs phi , different eta,  depth=4 *****" <<endl;
4126   c3x5->Clear();
4127   c3x5->Divide(3, 5);
4128   c3x5->cd(1);
4129   int kcountHEnegativedirectionRecosignalD4 = 1;
4130   TH1F* h2CeffHEnegativedirectionRecosignalD4 = new TH1F("h2CeffHEnegativedirectionRecosignalD4", "", nphi, 0., 72.);
4131 
4132   for (int jeta = 0; jeta < njeta; jeta++) {
4133     // negativedirectionRecosignalD:
4134     if (jeta - 41 < 0) {
4135       //         for (int i=0;i<ndepth;i++) {
4136       // depth=4
4137       for (int i = 3; i < 4; i++) {
4138         TH1F* HEnegativedirectionRecosignalD4 = (TH1F*)h2CeffHEnegativedirectionRecosignalD4->Clone("twod1");
4139 
4140         float ccctest = 0;  // to avoid empty massive elements
4141         for (int jphi = 0; jphi < nphi; jphi++) {
4142           double ccc1 = recosignalvariancehe[i][jeta][jphi];
4143           if (arecosignalhe[i][jeta][jphi] > 0.) {
4144             HEnegativedirectionRecosignalD4->Fill(jphi, ccc1);
4145             ccctest = 1.;  //HEnegativedirectionRecosignalD4->SetBinError(i,0.01);
4146           }
4147         }  // for jphi
4148         if (ccctest > 0.) {
4149           //cout<<"1717       kcountHEnegativedirectionRecosignalD4   =     "<<kcountHEnegativedirectionRecosignalD4  <<"   jeta-41=     "<< jeta-41 <<endl;
4150           c3x5->cd(kcountHEnegativedirectionRecosignalD4);
4151           HEnegativedirectionRecosignalD4->SetMarkerStyle(20);
4152           HEnegativedirectionRecosignalD4->SetMarkerSize(0.4);
4153           HEnegativedirectionRecosignalD4->GetYaxis()->SetLabelSize(0.04);
4154           HEnegativedirectionRecosignalD4->SetXTitle("HEnegativedirectionRecosignalD4 \b");
4155           HEnegativedirectionRecosignalD4->SetMarkerColor(2);
4156           HEnegativedirectionRecosignalD4->SetLineColor(0);
4157           gPad->SetGridy();
4158           gPad->SetGridx();
4159           //       gPad->SetLogy();
4160           if (kcountHEnegativedirectionRecosignalD4 == 1)
4161             HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-28; depth = 4 \b");
4162           if (kcountHEnegativedirectionRecosignalD4 == 2)
4163             HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-27; depth = 4 \b");
4164           if (kcountHEnegativedirectionRecosignalD4 == 3)
4165             HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-26; depth = 4 \b");
4166           if (kcountHEnegativedirectionRecosignalD4 == 4)
4167             HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-25; depth = 4 \b");
4168           if (kcountHEnegativedirectionRecosignalD4 == 5)
4169             HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-24; depth = 4 \b");
4170           if (kcountHEnegativedirectionRecosignalD4 == 6)
4171             HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-23; depth = 4 \b");
4172           if (kcountHEnegativedirectionRecosignalD4 == 7)
4173             HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-22; depth = 4 \b");
4174           if (kcountHEnegativedirectionRecosignalD4 == 8)
4175             HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-21; depth = 4 \b");
4176           if (kcountHEnegativedirectionRecosignalD4 == 9)
4177             HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-20; depth = 4 \b");
4178           if (kcountHEnegativedirectionRecosignalD4 == 10)
4179             HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-19; depth = 4 \b");
4180           if (kcountHEnegativedirectionRecosignalD4 == 11)
4181             HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-18; depth = 4 \b");
4182           if (kcountHEnegativedirectionRecosignalD4 == 12)
4183             HEnegativedirectionRecosignalD4->SetXTitle("D for HE- jeta =-16; depth = 4 \b");
4184           HEnegativedirectionRecosignalD4->Draw("Error");
4185           kcountHEnegativedirectionRecosignalD4++;
4186           if (kcountHEnegativedirectionRecosignalD4 > 12)
4187             break;  // 4x6 = 24
4188         }           //ccctest>0
4189 
4190       }  // for i
4191     }    //if(jeta-41 < 0)
4192   }      //for jeta
4193   /////////////////
4194   c3x5->Update();
4195   c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth4HE.png");
4196   c3x5->Clear();
4197   // clean-up
4198   if (h2CeffHEnegativedirectionRecosignalD4)
4199     delete h2CeffHEnegativedirectionRecosignalD4;
4200   //========================================================================================== 22222218
4201   //======================================================================
4202   //======================================================================1D plot: D vs phi , different eta,  depth=5
4203   //cout<<"      1D plot: D vs phi , different eta,  depth=5 *****" <<endl;
4204   c3x5->Clear();
4205   c3x5->Divide(3, 5);
4206   c3x5->cd(1);
4207   int kcountHEnegativedirectionRecosignalD5 = 1;
4208   TH1F* h2CeffHEnegativedirectionRecosignalD5 = new TH1F("h2CeffHEnegativedirectionRecosignalD5", "", nphi, 0., 72.);
4209 
4210   for (int jeta = 0; jeta < njeta; jeta++) {
4211     // negativedirectionRecosignalD:
4212     if (jeta - 41 < 0) {
4213       //         for (int i=0;i<ndepth;i++) {
4214       // depth=5
4215       for (int i = 4; i < 5; i++) {
4216         TH1F* HEnegativedirectionRecosignalD5 = (TH1F*)h2CeffHEnegativedirectionRecosignalD5->Clone("twod1");
4217 
4218         float ccctest = 0;  // to avoid empty massive elements
4219         for (int jphi = 0; jphi < nphi; jphi++) {
4220           double ccc1 = recosignalvariancehe[i][jeta][jphi];
4221           if (arecosignalhe[i][jeta][jphi] > 0.) {
4222             HEnegativedirectionRecosignalD5->Fill(jphi, ccc1);
4223             ccctest = 1.;  //HEnegativedirectionRecosignalD5->SetBinError(i,0.01);
4224           }
4225         }  // for jphi
4226         if (ccctest > 0.) {
4227           //cout<<"1818       kcountHEnegativedirectionRecosignalD5   =     "<<kcountHEnegativedirectionRecosignalD5  <<"   jeta-41=     "<< jeta-41 <<endl;
4228           c3x5->cd(kcountHEnegativedirectionRecosignalD5);
4229           HEnegativedirectionRecosignalD5->SetMarkerStyle(20);
4230           HEnegativedirectionRecosignalD5->SetMarkerSize(0.4);
4231           HEnegativedirectionRecosignalD5->GetYaxis()->SetLabelSize(0.04);
4232           HEnegativedirectionRecosignalD5->SetXTitle("HEnegativedirectionRecosignalD5 \b");
4233           HEnegativedirectionRecosignalD5->SetMarkerColor(2);
4234           HEnegativedirectionRecosignalD5->SetLineColor(0);
4235           gPad->SetGridy();
4236           gPad->SetGridx();
4237           //       gPad->SetLogy();
4238           if (kcountHEnegativedirectionRecosignalD5 == 1)
4239             HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-28; depth = 5 \b");
4240           if (kcountHEnegativedirectionRecosignalD5 == 2)
4241             HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-27; depth = 5 \b");
4242           if (kcountHEnegativedirectionRecosignalD5 == 3)
4243             HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-26; depth = 5 \b");
4244           if (kcountHEnegativedirectionRecosignalD5 == 4)
4245             HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-25; depth = 5 \b");
4246           if (kcountHEnegativedirectionRecosignalD5 == 5)
4247             HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-24; depth = 5 \b");
4248           if (kcountHEnegativedirectionRecosignalD5 == 6)
4249             HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-23; depth = 5 \b");
4250           if (kcountHEnegativedirectionRecosignalD5 == 7)
4251             HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-22; depth = 5 \b");
4252           if (kcountHEnegativedirectionRecosignalD5 == 8)
4253             HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-21; depth = 5 \b");
4254           if (kcountHEnegativedirectionRecosignalD5 == 9)
4255             HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-20; depth = 5 \b");
4256           if (kcountHEnegativedirectionRecosignalD5 == 10)
4257             HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-19; depth = 5 \b");
4258           if (kcountHEnegativedirectionRecosignalD5 == 11)
4259             HEnegativedirectionRecosignalD5->SetXTitle("D for HE- jeta =-18; depth = 5 \b");
4260           HEnegativedirectionRecosignalD5->Draw("Error");
4261           kcountHEnegativedirectionRecosignalD5++;
4262           if (kcountHEnegativedirectionRecosignalD5 > 11)
4263             break;  // 4x6 = 24
4264         }           //ccctest>0
4265 
4266       }  // for i
4267     }    //if(jeta-41 < 0)
4268   }      //for jeta
4269   /////////////////
4270   c3x5->Update();
4271   c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth5HE.png");
4272   c3x5->Clear();
4273   // clean-up
4274   if (h2CeffHEnegativedirectionRecosignalD5)
4275     delete h2CeffHEnegativedirectionRecosignalD5;
4276   //========================================================================================== 22222219
4277   //======================================================================
4278   //======================================================================1D plot: D vs phi , different eta,  depth=6
4279   //cout<<"      1D plot: D vs phi , different eta,  depth=6 *****" <<endl;
4280   c3x5->Clear();
4281   c3x5->Divide(3, 5);
4282   c3x5->cd(1);
4283   int kcountHEnegativedirectionRecosignalD6 = 1;
4284   TH1F* h2CeffHEnegativedirectionRecosignalD6 = new TH1F("h2CeffHEnegativedirectionRecosignalD6", "", nphi, 0., 72.);
4285 
4286   for (int jeta = 0; jeta < njeta; jeta++) {
4287     // negativedirectionRecosignalD:
4288     if (jeta - 41 < 0) {
4289       //         for (int i=0;i<ndepth;i++) {
4290       // depth=6
4291       for (int i = 5; i < 6; i++) {
4292         TH1F* HEnegativedirectionRecosignalD6 = (TH1F*)h2CeffHEnegativedirectionRecosignalD6->Clone("twod1");
4293 
4294         float ccctest = 0;  // to avoid empty massive elements
4295         for (int jphi = 0; jphi < nphi; jphi++) {
4296           double ccc1 = recosignalvariancehe[i][jeta][jphi];
4297           if (arecosignalhe[i][jeta][jphi] > 0.) {
4298             HEnegativedirectionRecosignalD6->Fill(jphi, ccc1);
4299             ccctest = 1.;  //HEnegativedirectionRecosignalD6->SetBinError(i,0.01);
4300           }
4301         }  // for jphi
4302         if (ccctest > 0.) {
4303           //cout<<"1919       kcountHEnegativedirectionRecosignalD6   =     "<<kcountHEnegativedirectionRecosignalD6  <<"   jeta-41=     "<< jeta-41 <<endl;
4304           c3x5->cd(kcountHEnegativedirectionRecosignalD6);
4305           HEnegativedirectionRecosignalD6->SetMarkerStyle(20);
4306           HEnegativedirectionRecosignalD6->SetMarkerSize(0.4);
4307           HEnegativedirectionRecosignalD6->GetYaxis()->SetLabelSize(0.04);
4308           HEnegativedirectionRecosignalD6->SetXTitle("HEnegativedirectionRecosignalD6 \b");
4309           HEnegativedirectionRecosignalD6->SetMarkerColor(2);
4310           HEnegativedirectionRecosignalD6->SetLineColor(0);
4311           gPad->SetGridy();
4312           gPad->SetGridx();
4313           //       gPad->SetLogy();
4314           if (kcountHEnegativedirectionRecosignalD6 == 1)
4315             HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-28; depth = 6 \b");
4316           if (kcountHEnegativedirectionRecosignalD6 == 2)
4317             HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-27; depth = 6 \b");
4318           if (kcountHEnegativedirectionRecosignalD6 == 3)
4319             HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-26; depth = 6 \b");
4320           if (kcountHEnegativedirectionRecosignalD6 == 4)
4321             HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-25; depth = 6 \b");
4322           if (kcountHEnegativedirectionRecosignalD6 == 5)
4323             HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-24; depth = 6 \b");
4324           if (kcountHEnegativedirectionRecosignalD6 == 6)
4325             HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-23; depth = 6 \b");
4326           if (kcountHEnegativedirectionRecosignalD6 == 7)
4327             HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-22; depth = 6 \b");
4328           if (kcountHEnegativedirectionRecosignalD6 == 8)
4329             HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-21; depth = 6 \b");
4330           if (kcountHEnegativedirectionRecosignalD6 == 9)
4331             HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-20; depth = 6 \b");
4332           if (kcountHEnegativedirectionRecosignalD6 == 10)
4333             HEnegativedirectionRecosignalD6->SetXTitle("D for HE- jeta =-19; depth = 6 \b");
4334           HEnegativedirectionRecosignalD6->Draw("Error");
4335           kcountHEnegativedirectionRecosignalD6++;
4336           if (kcountHEnegativedirectionRecosignalD6 > 10)
4337             break;  // 4x6 = 24
4338         }           //ccctest>0
4339 
4340       }  // for i
4341     }    //if(jeta-41 < 0)
4342   }      //for jeta
4343   /////////////////
4344   c3x5->Update();
4345   c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth6HE.png");
4346   c3x5->Clear();
4347   // clean-up
4348   if (h2CeffHEnegativedirectionRecosignalD6)
4349     delete h2CeffHEnegativedirectionRecosignalD6;
4350   //========================================================================================== 22222220
4351   //======================================================================
4352   //======================================================================1D plot: D vs phi , different eta,  depth=7
4353   //cout<<"      1D plot: D vs phi , different eta,  depth=7 *****" <<endl;
4354   c3x5->Clear();
4355   c3x5->Divide(3, 5);
4356   c3x5->cd(1);
4357   int kcountHEnegativedirectionRecosignalD7 = 1;
4358   TH1F* h2CeffHEnegativedirectionRecosignalD7 = new TH1F("h2CeffHEnegativedirectionRecosignalD7", "", nphi, 0., 72.);
4359 
4360   for (int jeta = 0; jeta < njeta; jeta++) {
4361     // negativedirectionRecosignalD:
4362     if (jeta - 41 < 0) {
4363       //         for (int i=0;i<ndepth;i++) {
4364       // depth=7
4365       for (int i = 6; i < 7; i++) {
4366         TH1F* HEnegativedirectionRecosignalD7 = (TH1F*)h2CeffHEnegativedirectionRecosignalD7->Clone("twod1");
4367 
4368         float ccctest = 0;  // to avoid empty massive elements
4369         for (int jphi = 0; jphi < nphi; jphi++) {
4370           double ccc1 = recosignalvariancehe[i][jeta][jphi];
4371           if (arecosignalhe[i][jeta][jphi] > 0.) {
4372             HEnegativedirectionRecosignalD7->Fill(jphi, ccc1);
4373             ccctest = 1.;  //HEnegativedirectionRecosignalD7->SetBinError(i,0.01);
4374           }
4375         }  // for jphi
4376         if (ccctest != 0.) {
4377           //cout<<"2020       kcountHEnegativedirectionRecosignalD7   =     "<<kcountHEnegativedirectionRecosignalD7  <<"   jeta-41=     "<< jeta-41 <<endl;
4378           c3x5->cd(kcountHEnegativedirectionRecosignalD7);
4379           HEnegativedirectionRecosignalD7->SetMarkerStyle(20);
4380           HEnegativedirectionRecosignalD7->SetMarkerSize(0.4);
4381           HEnegativedirectionRecosignalD7->GetYaxis()->SetLabelSize(0.04);
4382           HEnegativedirectionRecosignalD7->SetXTitle("HEnegativedirectionRecosignalD7 \b");
4383           HEnegativedirectionRecosignalD7->SetMarkerColor(2);
4384           HEnegativedirectionRecosignalD7->SetLineColor(0);
4385           gPad->SetGridy();
4386           gPad->SetGridx();
4387           //       gPad->SetLogy();
4388           if (kcountHEnegativedirectionRecosignalD7 == 1)
4389             HEnegativedirectionRecosignalD7->SetXTitle("D for HE- jeta =-28; depth = 7 \b");
4390           if (kcountHEnegativedirectionRecosignalD7 == 2)
4391             HEnegativedirectionRecosignalD7->SetXTitle("D for HE- jeta =-27; depth = 7 \b");
4392           if (kcountHEnegativedirectionRecosignalD7 == 3)
4393             HEnegativedirectionRecosignalD7->SetXTitle("D for HE- jeta =-26; depth = 7 \b");
4394           HEnegativedirectionRecosignalD7->Draw("Error");
4395           kcountHEnegativedirectionRecosignalD7++;
4396           if (kcountHEnegativedirectionRecosignalD7 > 3)
4397             break;  // 4x6 = 24
4398         }           //ccctest>0
4399 
4400       }  // for i
4401     }    //if(jeta-41 < 0)
4402   }      //for jeta
4403   /////////////////
4404   c3x5->Update();
4405   c3x5->Print("DrecosignalNegativeDirectionhistD1PhiSymmetryDepth7HE.png");
4406   c3x5->Clear();
4407   // clean-up
4408   if (h2CeffHEnegativedirectionRecosignalD7)
4409     delete h2CeffHEnegativedirectionRecosignalD7;
4410   //=====================================================================       END of Recosignal HE for phi-symmetry
4411   //=====================================================================       END of Recosignal HE for phi-symmetry
4412   //=====================================================================       END of Recosignal HE for phi-symmetry
4413   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Recosignal HF
4414   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Recosignal HF
4415   ////////////////////////////////////////////////////////////////////////////////////////////////////         Phi-symmetry for Calibration Group:    Recosignal HF
4416   //  int k_max[5]={0,4,7,4,4}; // maximum depth for each subdet
4417   //ndepth = k_max[5];
4418   ndepth = 2;
4419   double arecosignalHF[ndepth][njeta][njphi];
4420   double recosignalvarianceHF[ndepth][njeta][njphi];
4421   //cout<<"111RRRRRRRRRRRRRRRRRRRRRRRRR      Recosignal HF" <<endl;
4422   //                                   RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR:   Recosignal HF
4423   TH2F* recSignalEnergy1HF1 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy1_HF1");
4424   TH2F* recSignalEnergy0HF1 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HF1");
4425   TH2F* recSignalEnergyHF1 = (TH2F*)recSignalEnergy1HF1->Clone("recSignalEnergyHF1");
4426   recSignalEnergyHF1->Divide(recSignalEnergy1HF1, recSignalEnergy0HF1, 1, 1, "B");
4427   TH2F* recSignalEnergy1HF2 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy1_HF2");
4428   TH2F* recSignalEnergy0HF2 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HF2");
4429   TH2F* recSignalEnergyHF2 = (TH2F*)recSignalEnergy1HF2->Clone("recSignalEnergyHF2");
4430   recSignalEnergyHF2->Divide(recSignalEnergy1HF2, recSignalEnergy0HF2, 1, 1, "B");
4431   //  cout<<"222RRRRRRRRRRRRRRRRRRRRRRRRR      Recosignal HF" <<endl;
4432   //====================================================================== PHI normalization & put R into massive arecosignalHF
4433   for (int jeta = 0; jeta < njeta; jeta++) {
4434     //preparation for PHI normalization:
4435     double sumrecosignalHF0 = 0;
4436     int nsumrecosignalHF0 = 0;
4437     double sumrecosignalHF1 = 0;
4438     int nsumrecosignalHF1 = 0;
4439     for (int jphi = 0; jphi < njphi; jphi++) {
4440       arecosignalHF[0][jeta][jphi] = recSignalEnergyHF1->GetBinContent(jeta + 1, jphi + 1);
4441       arecosignalHF[1][jeta][jphi] = recSignalEnergyHF2->GetBinContent(jeta + 1, jphi + 1);
4442       if (arecosignalHF[0][jeta][jphi] > 0.) {
4443         sumrecosignalHF0 += arecosignalHF[0][jeta][jphi];
4444         ++nsumrecosignalHF0;
4445       }
4446       if (arecosignalHF[1][jeta][jphi] > 0.) {
4447         sumrecosignalHF1 += arecosignalHF[1][jeta][jphi];
4448         ++nsumrecosignalHF1;
4449       }
4450     }  // phi
4451     // PHI normalization:
4452     for (int jphi = 0; jphi < njphi; jphi++) {
4453       if (arecosignalHF[0][jeta][jphi] > 0.)
4454         arecosignalHF[0][jeta][jphi] /= (sumrecosignalHF0 / nsumrecosignalHF0);
4455       if (arecosignalHF[1][jeta][jphi] > 0.)
4456         arecosignalHF[1][jeta][jphi] /= (sumrecosignalHF1 / nsumrecosignalHF1);
4457     }  // phi
4458   }    //eta
4459   //------------------------  2D-eta/phi-plot: R, averaged over depthfs
4460   //======================================================================
4461   //======================================================================
4462   // cout<<"      R2D-eta/phi-plot: R, averaged over depthfs *****" <<endl;
4463   c2x1->Clear();
4464   /////////////////
4465   c2x1->Divide(2, 1);
4466   c2x1->cd(1);
4467   TH2F* GefzRrecosignalHF42D = new TH2F("GefzRrecosignalHF42D", "", neta, -41., 41., nphi, 0., 72.);
4468   TH2F* GefzRrecosignalHF42D0 = new TH2F("GefzRrecosignalHF42D0", "", neta, -41., 41., nphi, 0., 72.);
4469   TH2F* GefzRrecosignalHF42DF = (TH2F*)GefzRrecosignalHF42D0->Clone("GefzRrecosignalHF42DF");
4470   for (int i = 0; i < ndepth; i++) {
4471     for (int jeta = 0; jeta < neta; jeta++) {
4472       for (int jphi = 0; jphi < nphi; jphi++) {
4473         double ccc1 = arecosignalHF[i][jeta][jphi];
4474         int k2plot = jeta - 41;
4475         int kkk = k2plot;  //if(k2plot >0 ) kkk=k2plot+1; //-41 +41 !=0
4476         if (ccc1 != 0.) {
4477           GefzRrecosignalHF42D->Fill(kkk, jphi, ccc1);
4478           GefzRrecosignalHF42D0->Fill(kkk, jphi, 1.);
4479         }
4480       }
4481     }
4482   }
4483   GefzRrecosignalHF42DF->Divide(GefzRrecosignalHF42D, GefzRrecosignalHF42D0, 1, 1, "B");  // average A
4484   gPad->SetGridy();
4485   gPad->SetGridx();  //      gPad->SetLogz();
4486   GefzRrecosignalHF42DF->SetXTitle("<R>_depth       #eta  \b");
4487   GefzRrecosignalHF42DF->SetYTitle("      #phi \b");
4488   GefzRrecosignalHF42DF->Draw("COLZ");
4489 
4490   c2x1->cd(2);
4491   TH1F* energyhitSignal_HF = (TH1F*)dir->FindObjectAny("h_energyhitSignal_HF");
4492   energyhitSignal_HF->SetMarkerStyle(20);
4493   energyhitSignal_HF->SetMarkerSize(0.4);
4494   energyhitSignal_HF->GetYaxis()->SetLabelSize(0.04);
4495   energyhitSignal_HF->SetXTitle("energyhitSignal_HF \b");
4496   energyhitSignal_HF->SetMarkerColor(2);
4497   energyhitSignal_HF->SetLineColor(0);
4498   gPad->SetGridy();
4499   gPad->SetGridx();
4500   energyhitSignal_HF->Draw("Error");
4501 
4502   /////////////////
4503   c2x1->Update();
4504   c2x1->Print("RrecosignalGeneralD2PhiSymmetryHF.png");
4505   c2x1->Clear();
4506   // clean-up
4507   if (GefzRrecosignalHF42D)
4508     delete GefzRrecosignalHF42D;
4509   if (GefzRrecosignalHF42D0)
4510     delete GefzRrecosignalHF42D0;
4511   if (GefzRrecosignalHF42DF)
4512     delete GefzRrecosignalHF42DF;
4513   //====================================================================== 1D plot: R vs phi , averaged over depthfs & eta
4514   //======================================================================
4515   //cout<<"      1D plot: R vs phi , averaged over depthfs & eta *****" <<endl;
4516   c1x1->Clear();
4517   /////////////////
4518   c1x1->Divide(1, 1);
4519   c1x1->cd(1);
4520   TH1F* GefzRrecosignalHF41D = new TH1F("GefzRrecosignalHF41D", "", nphi, 0., 72.);
4521   TH1F* GefzRrecosignalHF41D0 = new TH1F("GefzRrecosignalHF41D0", "", nphi, 0., 72.);
4522   TH1F* GefzRrecosignalHF41DF = (TH1F*)GefzRrecosignalHF41D0->Clone("GefzRrecosignalHF41DF");
4523   for (int jphi = 0; jphi < nphi; jphi++) {
4524     for (int jeta = 0; jeta < neta; jeta++) {
4525       for (int i = 0; i < ndepth; i++) {
4526         double ccc1 = arecosignalHF[i][jeta][jphi];
4527         if (ccc1 != 0.) {
4528           GefzRrecosignalHF41D->Fill(jphi, ccc1);
4529           GefzRrecosignalHF41D0->Fill(jphi, 1.);
4530         }
4531       }
4532     }
4533   }
4534   GefzRrecosignalHF41DF->Divide(
4535       GefzRrecosignalHF41D, GefzRrecosignalHF41D0, 1, 1, "B");  // R averaged over depthfs & eta
4536   GefzRrecosignalHF41D0->Sumw2();
4537   //    for (int jphi=1;jphi<73;jphi++) {GefzRrecosignalHF41DF->SetBinError(jphi,0.01);}
4538   gPad->SetGridy();
4539   gPad->SetGridx();  //      gPad->SetLogz();
4540   GefzRrecosignalHF41DF->SetMarkerStyle(20);
4541   GefzRrecosignalHF41DF->SetMarkerSize(1.4);
4542   GefzRrecosignalHF41DF->GetZaxis()->SetLabelSize(0.08);
4543   GefzRrecosignalHF41DF->SetXTitle("#phi  \b");
4544   GefzRrecosignalHF41DF->SetYTitle("  <R> \b");
4545   GefzRrecosignalHF41DF->SetZTitle("<R>_PHI  - AllDepthfs \b");
4546   GefzRrecosignalHF41DF->SetMarkerColor(4);
4547   GefzRrecosignalHF41DF->SetLineColor(
4548       4);  //  GefzRrecosignalHF41DF->SetMinimum(0.8);     //      GefzRrecosignalHF41DF->SetMaximum(1.000);
4549   GefzRrecosignalHF41DF->Draw("Error");
4550   /////////////////
4551   c1x1->Update();
4552   c1x1->Print("RrecosignalGeneralD1PhiSymmetryHF.png");
4553   c1x1->Clear();
4554   // clean-up
4555   if (GefzRrecosignalHF41D)
4556     delete GefzRrecosignalHF41D;
4557   if (GefzRrecosignalHF41D0)
4558     delete GefzRrecosignalHF41D0;
4559   if (GefzRrecosignalHF41DF)
4560     delete GefzRrecosignalHF41DF;
4561   //========================================================================================== 4
4562   //======================================================================
4563   //======================================================================1D plot: R vs phi , different eta,  depth=1
4564   //cout<<"      1D plot: R vs phi , different eta,  depth=1 *****" <<endl;
4565   c3x5->Clear();
4566   /////////////////
4567   c3x5->Divide(3, 5);
4568   c3x5->cd(1);
4569   int kcountHFpositivedirectionRecosignal1 = 1;
4570   TH1F* h2CeffHFpositivedirectionRecosignal1 = new TH1F("h2CeffHFpositivedirectionRecosignal1", "", nphi, 0., 72.);
4571   for (int jeta = 0; jeta < njeta; jeta++) {
4572     // positivedirectionRecosignal:
4573     if (jeta - 41 >= 0) {
4574       //         for (int i=0;i<ndepth;i++) {
4575       // depth=1
4576       for (int i = 0; i < 1; i++) {
4577         TH1F* HFpositivedirectionRecosignal1 = (TH1F*)h2CeffHFpositivedirectionRecosignal1->Clone("twod1");
4578         float ccctest = 0;  // to avoid empty massive elements
4579         for (int jphi = 0; jphi < nphi; jphi++) {
4580           double ccc1 = arecosignalHF[i][jeta][jphi];
4581           if (ccc1 != 0.) {
4582             HFpositivedirectionRecosignal1->Fill(jphi, ccc1);
4583             ccctest = 1.;  //HFpositivedirectionRecosignal1->SetBinError(i,0.01);
4584           }
4585         }  // for jphi
4586         if (ccctest > 0.) {
4587           //      cout<<"444        kcountHFpositivedirectionRecosignal1   =     "<<kcountHFpositivedirectionRecosignal1  <<"   jeta-41=     "<< jeta-41 <<endl;
4588           c3x5->cd(kcountHFpositivedirectionRecosignal1);
4589           HFpositivedirectionRecosignal1->SetMarkerStyle(20);
4590           HFpositivedirectionRecosignal1->SetMarkerSize(0.4);
4591           HFpositivedirectionRecosignal1->GetYaxis()->SetLabelSize(0.04);
4592           HFpositivedirectionRecosignal1->SetXTitle("HFpositivedirectionRecosignal1 \b");
4593           HFpositivedirectionRecosignal1->SetMarkerColor(2);
4594           HFpositivedirectionRecosignal1->SetLineColor(0);
4595           gPad->SetGridy();
4596           gPad->SetGridx();
4597           //       gPad->SetLogy();
4598           if (kcountHFpositivedirectionRecosignal1 == 1)
4599             HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 28; depth = 1 \b");
4600           if (kcountHFpositivedirectionRecosignal1 == 2)
4601             HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 29; depth = 1 \b");
4602           if (kcountHFpositivedirectionRecosignal1 == 3)
4603             HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 30; depth = 1 \b");
4604           if (kcountHFpositivedirectionRecosignal1 == 4)
4605             HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 31; depth = 1 \b");
4606           if (kcountHFpositivedirectionRecosignal1 == 5)
4607             HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 32; depth = 1 \b");
4608           if (kcountHFpositivedirectionRecosignal1 == 6)
4609             HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 33; depth = 1 \b");
4610           if (kcountHFpositivedirectionRecosignal1 == 7)
4611             HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 34; depth = 1 \b");
4612           if (kcountHFpositivedirectionRecosignal1 == 8)
4613             HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 35; depth = 1 \b");
4614           if (kcountHFpositivedirectionRecosignal1 == 9)
4615             HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 36; depth = 1 \b");
4616           if (kcountHFpositivedirectionRecosignal1 == 10)
4617             HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 37; depth = 1 \b");
4618           if (kcountHFpositivedirectionRecosignal1 == 11)
4619             HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 38; depth = 1 \b");
4620           if (kcountHFpositivedirectionRecosignal1 == 12)
4621             HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 39; depth = 1 \b");
4622           if (kcountHFpositivedirectionRecosignal1 == 13)
4623             HFpositivedirectionRecosignal1->SetXTitle("R for HF+ jeta = 40; depth = 1 \b");
4624           HFpositivedirectionRecosignal1->Draw("Error");
4625           kcountHFpositivedirectionRecosignal1++;
4626           if (kcountHFpositivedirectionRecosignal1 > 13)
4627             break;  //
4628         }           //ccctest>0
4629 
4630       }  // for i
4631     }    //if(jeta-41 >= 0)
4632   }      //for jeta
4633   /////////////////
4634   c3x5->Update();
4635   c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth1HF.png");
4636   c3x5->Clear();
4637   // clean-up
4638   if (h2CeffHFpositivedirectionRecosignal1)
4639     delete h2CeffHFpositivedirectionRecosignal1;
4640 
4641   //========================================================================================== 5
4642   //======================================================================
4643   //======================================================================1D plot: R vs phi , different eta,  depth=2
4644   //  cout<<"      1D plot: R vs phi , different eta,  depth=2 *****" <<endl;
4645   c3x5->Clear();
4646   /////////////////
4647   c3x5->Divide(3, 5);
4648   c3x5->cd(1);
4649   int kcountHFpositivedirectionRecosignal2 = 1;
4650   TH1F* h2CeffHFpositivedirectionRecosignal2 = new TH1F("h2CeffHFpositivedirectionRecosignal2", "", nphi, 0., 72.);
4651   for (int jeta = 0; jeta < njeta; jeta++) {
4652     // positivedirectionRecosignal:
4653     if (jeta - 41 >= 0) {
4654       //         for (int i=0;i<ndepth;i++) {
4655       // depth=2
4656       for (int i = 1; i < 2; i++) {
4657         TH1F* HFpositivedirectionRecosignal2 = (TH1F*)h2CeffHFpositivedirectionRecosignal2->Clone("twod1");
4658         float ccctest = 0;  // to avoid empty massive elements
4659         for (int jphi = 0; jphi < nphi; jphi++) {
4660           double ccc1 = arecosignalHF[i][jeta][jphi];
4661           if (ccc1 != 0.) {
4662             HFpositivedirectionRecosignal2->Fill(jphi, ccc1);
4663             ccctest = 1.;  //HFpositivedirectionRecosignal2->SetBinError(i,0.01);
4664           }
4665         }  // for jphi
4666         if (ccctest > 0.) {
4667           //cout<<"555        kcountHFpositivedirectionRecosignal2   =     "<<kcountHFpositivedirectionRecosignal2  <<"   jeta-41=     "<< jeta-41 <<endl;
4668           c3x5->cd(kcountHFpositivedirectionRecosignal2);
4669           HFpositivedirectionRecosignal2->SetMarkerStyle(20);
4670           HFpositivedirectionRecosignal2->SetMarkerSize(0.4);
4671           HFpositivedirectionRecosignal2->GetYaxis()->SetLabelSize(0.04);
4672           HFpositivedirectionRecosignal2->SetXTitle("HFpositivedirectionRecosignal2 \b");
4673           HFpositivedirectionRecosignal2->SetMarkerColor(2);
4674           HFpositivedirectionRecosignal2->SetLineColor(0);
4675           gPad->SetGridy();
4676           gPad->SetGridx();
4677           //       gPad->SetLogy();
4678           if (kcountHFpositivedirectionRecosignal2 == 1)
4679             HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 28; depth = 2 \b");
4680           if (kcountHFpositivedirectionRecosignal2 == 2)
4681             HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 29; depth = 2 \b");
4682           if (kcountHFpositivedirectionRecosignal2 == 3)
4683             HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 30; depth = 2 \b");
4684           if (kcountHFpositivedirectionRecosignal2 == 4)
4685             HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 31; depth = 2 \b");
4686           if (kcountHFpositivedirectionRecosignal2 == 5)
4687             HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 32; depth = 2 \b");
4688           if (kcountHFpositivedirectionRecosignal2 == 6)
4689             HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 33; depth = 2 \b");
4690           if (kcountHFpositivedirectionRecosignal2 == 7)
4691             HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 34; depth = 2 \b");
4692           if (kcountHFpositivedirectionRecosignal2 == 8)
4693             HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 35; depth = 2 \b");
4694           if (kcountHFpositivedirectionRecosignal2 == 9)
4695             HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 36; depth = 2 \b");
4696           if (kcountHFpositivedirectionRecosignal2 == 10)
4697             HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 37; depth = 2 \b");
4698           if (kcountHFpositivedirectionRecosignal2 == 11)
4699             HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 38; depth = 2 \b");
4700           if (kcountHFpositivedirectionRecosignal2 == 12)
4701             HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 39; depth = 2 \b");
4702           if (kcountHFpositivedirectionRecosignal2 == 13)
4703             HFpositivedirectionRecosignal2->SetXTitle("R for HF+ jeta = 40; depth = 2 \b");
4704           HFpositivedirectionRecosignal2->Draw("Error");
4705           kcountHFpositivedirectionRecosignal2++;
4706           if (kcountHFpositivedirectionRecosignal2 > 13)
4707             break;  // 4x6 = 24
4708         }           //ccctest>0
4709 
4710       }  // for i
4711     }    //if(jeta-41 >= 0)
4712   }      //for jeta
4713   /////////////////
4714   c3x5->Update();
4715   c3x5->Print("RrecosignalPositiveDirectionhistD1PhiSymmetryDepth2HF.png");
4716   c3x5->Clear();
4717   // clean-up
4718   if (h2CeffHFpositivedirectionRecosignal2)
4719     delete h2CeffHFpositivedirectionRecosignal2;
4720 
4721   //========================================================================================== 1111114
4722   //======================================================================
4723   //======================================================================1D plot: R vs phi , different eta,  depth=1
4724   //cout<<"      1D plot: R vs phi , different eta,  depth=1 *****" <<endl;
4725   c3x5->Clear();
4726   /////////////////
4727   c3x5->Divide(3, 5);
4728   c3x5->cd(1);
4729   int kcountHFnegativedirectionRecosignal1 = 1;
4730   TH1F* h2CeffHFnegativedirectionRecosignal1 = new TH1F("h2CeffHFnegativedirectionRecosignal1", "", nphi, 0., 72.);
4731   for (int jeta = 0; jeta < njeta; jeta++) {
4732     // negativedirectionRecosignal:
4733     if (jeta - 41 < 0) {
4734       //         for (int i=0;i<ndepth;i++) {
4735       // depth=1
4736       for (int i = 0; i < 1; i++) {
4737         TH1F* HFnegativedirectionRecosignal1 = (TH1F*)h2CeffHFnegativedirectionRecosignal1->Clone("twod1");
4738         float ccctest = 0;  // to avoid empty massive elements
4739         for (int jphi = 0; jphi < nphi; jphi++) {
4740           double ccc1 = arecosignalHF[i][jeta][jphi];
4741           if (ccc1 != 0.) {
4742             HFnegativedirectionRecosignal1->Fill(jphi, ccc1);
4743             ccctest = 1.;  //HFnegativedirectionRecosignal1->SetBinError(i,0.01);
4744           }
4745         }  // for jphi
4746         if (ccctest > 0.) {
4747           //      cout<<"444        kcountHFnegativedirectionRecosignal1   =     "<<kcountHFnegativedirectionRecosignal1  <<"   jeta-41=     "<< jeta-41 <<endl;
4748           c3x5->cd(kcountHFnegativedirectionRecosignal1);
4749           HFnegativedirectionRecosignal1->SetMarkerStyle(20);
4750           HFnegativedirectionRecosignal1->SetMarkerSize(0.4);
4751           HFnegativedirectionRecosignal1->GetYaxis()->SetLabelSize(0.04);
4752           HFnegativedirectionRecosignal1->SetXTitle("HFnegativedirectionRecosignal1 \b");
4753           HFnegativedirectionRecosignal1->SetMarkerColor(2);
4754           HFnegativedirectionRecosignal1->SetLineColor(0);
4755           gPad->SetGridy();
4756           gPad->SetGridx();
4757           //       gPad->SetLogy();
4758           if (kcountHFnegativedirectionRecosignal1 == 1)
4759             HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-41; depth = 1 \b");
4760           if (kcountHFnegativedirectionRecosignal1 == 2)
4761             HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-40; depth = 1 \b");
4762           if (kcountHFnegativedirectionRecosignal1 == 3)
4763             HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-39; depth = 1 \b");
4764           if (kcountHFnegativedirectionRecosignal1 == 4)
4765             HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-38; depth = 1 \b");
4766           if (kcountHFnegativedirectionRecosignal1 == 5)
4767             HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-37; depth = 1 \b");
4768           if (kcountHFnegativedirectionRecosignal1 == 6)
4769             HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-36; depth = 1 \b");
4770           if (kcountHFnegativedirectionRecosignal1 == 7)
4771             HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-35; depth = 1 \b");
4772           if (kcountHFnegativedirectionRecosignal1 == 8)
4773             HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-34; depth = 1 \b");
4774           if (kcountHFnegativedirectionRecosignal1 == 9)
4775             HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-33; depth = 1 \b");
4776           if (kcountHFnegativedirectionRecosignal1 == 10)
4777             HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-32; depth = 1 \b");
4778           if (kcountHFnegativedirectionRecosignal1 == 11)
4779             HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-31; depth = 1 \b");
4780           if (kcountHFnegativedirectionRecosignal1 == 12)
4781             HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-30; depth = 1 \b");
4782           if (kcountHFnegativedirectionRecosignal1 == 13)
4783             HFnegativedirectionRecosignal1->SetXTitle("R for HF- jeta =-29; depth = 1 \b");
4784           HFnegativedirectionRecosignal1->Draw("Error");
4785           kcountHFnegativedirectionRecosignal1++;
4786           if (kcountHFnegativedirectionRecosignal1 > 13)
4787             break;  //
4788         }           //ccctest>0
4789 
4790       }  // for i
4791     }    //if(jeta-41< 0)
4792   }      //for jeta
4793   /////////////////
4794   c3x5->Update();
4795   c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth1HF.png");
4796   c3x5->Clear();
4797   // clean-up
4798   if (h2CeffHFnegativedirectionRecosignal1)
4799     delete h2CeffHFnegativedirectionRecosignal1;
4800 
4801   //========================================================================================== 1111115
4802   //======================================================================
4803   //======================================================================1D plot: R vs phi , different eta,  depth=2
4804   //  cout<<"      1D plot: R vs phi , different eta,  depth=2 *****" <<endl;
4805   c3x5->Clear();
4806   /////////////////
4807   c3x5->Divide(3, 5);
4808   c3x5->cd(1);
4809   int kcountHFnegativedirectionRecosignal2 = 1;
4810   TH1F* h2CeffHFnegativedirectionRecosignal2 = new TH1F("h2CeffHFnegativedirectionRecosignal2", "", nphi, 0., 72.);
4811   for (int jeta = 0; jeta < njeta; jeta++) {
4812     // negativedirectionRecosignal:
4813     if (jeta - 41 < 0) {
4814       //         for (int i=0;i<ndepth;i++) {
4815       // depth=2
4816       for (int i = 1; i < 2; i++) {
4817         TH1F* HFnegativedirectionRecosignal2 = (TH1F*)h2CeffHFnegativedirectionRecosignal2->Clone("twod1");
4818         float ccctest = 0;  // to avoid empty massive elements
4819         for (int jphi = 0; jphi < nphi; jphi++) {
4820           double ccc1 = arecosignalHF[i][jeta][jphi];
4821           if (ccc1 != 0.) {
4822             HFnegativedirectionRecosignal2->Fill(jphi, ccc1);
4823             ccctest = 1.;  //HFnegativedirectionRecosignal2->SetBinError(i,0.01);
4824           }
4825         }  // for jphi
4826         if (ccctest > 0.) {
4827           //cout<<"555        kcountHFnegativedirectionRecosignal2   =     "<<kcountHFnegativedirectionRecosignal2  <<"   jeta-41=     "<< jeta-41 <<endl;
4828           c3x5->cd(kcountHFnegativedirectionRecosignal2);
4829           HFnegativedirectionRecosignal2->SetMarkerStyle(20);
4830           HFnegativedirectionRecosignal2->SetMarkerSize(0.4);
4831           HFnegativedirectionRecosignal2->GetYaxis()->SetLabelSize(0.04);
4832           HFnegativedirectionRecosignal2->SetXTitle("HFnegativedirectionRecosignal2 \b");
4833           HFnegativedirectionRecosignal2->SetMarkerColor(2);
4834           HFnegativedirectionRecosignal2->SetLineColor(0);
4835           gPad->SetGridy();
4836           gPad->SetGridx();
4837           //       gPad->SetLogy();
4838           if (kcountHFnegativedirectionRecosignal2 == 1)
4839             HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-41; depth = 2 \b");
4840           if (kcountHFnegativedirectionRecosignal2 == 2)
4841             HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-40; depth = 2 \b");
4842           if (kcountHFnegativedirectionRecosignal2 == 3)
4843             HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-39; depth = 2 \b");
4844           if (kcountHFnegativedirectionRecosignal2 == 4)
4845             HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-38; depth = 2 \b");
4846           if (kcountHFnegativedirectionRecosignal2 == 5)
4847             HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-37; depth = 2 \b");
4848           if (kcountHFnegativedirectionRecosignal2 == 6)
4849             HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-36; depth = 2 \b");
4850           if (kcountHFnegativedirectionRecosignal2 == 7)
4851             HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-35; depth = 2 \b");
4852           if (kcountHFnegativedirectionRecosignal2 == 8)
4853             HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-34; depth = 2 \b");
4854           if (kcountHFnegativedirectionRecosignal2 == 9)
4855             HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-33; depth = 2 \b");
4856           if (kcountHFnegativedirectionRecosignal2 == 10)
4857             HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-32; depth = 2 \b");
4858           if (kcountHFnegativedirectionRecosignal2 == 11)
4859             HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-31; depth = 2 \b");
4860           if (kcountHFnegativedirectionRecosignal2 == 12)
4861             HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-30; depth = 2 \b");
4862           if (kcountHFnegativedirectionRecosignal2 == 13)
4863             HFnegativedirectionRecosignal2->SetXTitle("R for HF- jeta =-20; depth = 2 \b");
4864           HFnegativedirectionRecosignal2->Draw("Error");
4865           kcountHFnegativedirectionRecosignal2++;
4866           if (kcountHFnegativedirectionRecosignal2 > 13)
4867             break;  // 4x6 = 24
4868         }           //ccctest>0
4869 
4870       }  // for i
4871     }    //if(jeta-41< 0)
4872   }      //for jeta
4873   /////////////////
4874   c3x5->Update();
4875   c3x5->Print("RrecosignalNegativeDirectionhistD1PhiSymmetryDepth2HF.png");
4876   c3x5->Clear();
4877   // clean-up
4878   if (h2CeffHFnegativedirectionRecosignal2)
4879     delete h2CeffHFnegativedirectionRecosignal2;
4880 
4881   //======================================================================================================================
4882   //======================================================================================================================
4883   //======================================================================================================================
4884   //                            DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD:
4885 
4886   //cout<<"    Start Vaiance: preparation  *****" <<endl;
4887   TH2F* recosignalVariance1HF1 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy2_HF1");
4888   TH2F* recosignalVariance0HF1 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HF1");
4889   TH2F* recosignalVarianceHF1 = (TH2F*)recosignalVariance1HF1->Clone("recosignalVarianceHF1");
4890   recosignalVarianceHF1->Divide(recosignalVariance1HF1, recosignalVariance0HF1, 1, 1, "B");
4891   TH2F* recosignalVariance1HF2 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy2_HF2");
4892   TH2F* recosignalVariance0HF2 = (TH2F*)dir->FindObjectAny("h_recSignalEnergy0_HF2");
4893   TH2F* recosignalVarianceHF2 = (TH2F*)recosignalVariance1HF2->Clone("recosignalVarianceHF2");
4894   recosignalVarianceHF2->Divide(recosignalVariance1HF2, recosignalVariance0HF2, 1, 1, "B");
4895   //cout<<"      Vaiance: preparation DONE *****" <<endl;
4896   //====================================================================== put Vaiance=Dispersia = Sig**2=<R**2> - (<R>)**2 into massive recosignalvarianceHF
4897   //                                                                                           = sum(R*R)/N - (sum(R)/N)**2
4898   for (int jeta = 0; jeta < njeta; jeta++) {
4899     //preparation for PHI normalization:
4900     double sumrecosignalHF0 = 0;
4901     int nsumrecosignalHF0 = 0;
4902     double sumrecosignalHF1 = 0;
4903     int nsumrecosignalHF1 = 0;
4904     for (int jphi = 0; jphi < njphi; jphi++) {
4905       recosignalvarianceHF[0][jeta][jphi] = recosignalVarianceHF1->GetBinContent(jeta + 1, jphi + 1);
4906       recosignalvarianceHF[1][jeta][jphi] = recosignalVarianceHF2->GetBinContent(jeta + 1, jphi + 1);
4907       if (recosignalvarianceHF[0][jeta][jphi] > 0.) {
4908         sumrecosignalHF0 += recosignalvarianceHF[0][jeta][jphi];
4909         ++nsumrecosignalHF0;
4910       }
4911       if (recosignalvarianceHF[1][jeta][jphi] > 0.) {
4912         sumrecosignalHF1 += recosignalvarianceHF[1][jeta][jphi];
4913         ++nsumrecosignalHF1;
4914       }
4915     }  // phi
4916     // PHI normalization :
4917     for (int jphi = 0; jphi < njphi; jphi++) {
4918       if (recosignalvarianceHF[0][jeta][jphi] > 0.)
4919         recosignalvarianceHF[0][jeta][jphi] /= (sumrecosignalHF0 / nsumrecosignalHF0);
4920       if (recosignalvarianceHF[1][jeta][jphi] > 0.)
4921         recosignalvarianceHF[1][jeta][jphi] /= (sumrecosignalHF1 / nsumrecosignalHF1);
4922     }  // phi
4923     //       recosignalvarianceHF (D)           = sum(R*R)/N - (sum(R)/N)**2
4924     for (int jphi = 0; jphi < njphi; jphi++) {
4925       //       cout<<"12 12 12   jeta=     "<< jeta <<"   jphi   =     "<<jphi  <<endl;
4926       recosignalvarianceHF[0][jeta][jphi] -= arecosignalHF[0][jeta][jphi] * arecosignalHF[0][jeta][jphi];
4927       recosignalvarianceHF[0][jeta][jphi] = fabs(recosignalvarianceHF[0][jeta][jphi]);
4928       recosignalvarianceHF[1][jeta][jphi] -= arecosignalHF[1][jeta][jphi] * arecosignalHF[1][jeta][jphi];
4929       recosignalvarianceHF[1][jeta][jphi] = fabs(recosignalvarianceHF[1][jeta][jphi]);
4930     }
4931   }
4932   //cout<<"      Vaiance: DONE*****" <<endl;
4933   //------------------------  2D-eta/phi-plot: D, averaged over depthfs
4934   //======================================================================
4935   //======================================================================
4936   //cout<<"      R2D-eta/phi-plot: D, averaged over depthfs *****" <<endl;
4937   c1x1->Clear();
4938   /////////////////
4939   c1x0->Divide(1, 1);
4940   c1x0->cd(1);
4941   TH2F* DefzDrecosignalHF42D = new TH2F("DefzDrecosignalHF42D", "", neta, -41., 41., nphi, 0., 72.);
4942   TH2F* DefzDrecosignalHF42D0 = new TH2F("DefzDrecosignalHF42D0", "", neta, -41., 41., nphi, 0., 72.);
4943   TH2F* DefzDrecosignalHF42DF = (TH2F*)DefzDrecosignalHF42D0->Clone("DefzDrecosignalHF42DF");
4944   for (int i = 0; i < ndepth; i++) {
4945     for (int jeta = 0; jeta < neta; jeta++) {
4946       for (int jphi = 0; jphi < nphi; jphi++) {
4947         double ccc1 = recosignalvarianceHF[i][jeta][jphi];
4948         int k2plot = jeta - 41;
4949         int kkk = k2plot;  //if(k2plot >0   kkk=k2plot+1; //-41 +41 !=0
4950         if (arecosignalHF[i][jeta][jphi] > 0.) {
4951           DefzDrecosignalHF42D->Fill(kkk, jphi, ccc1);
4952           DefzDrecosignalHF42D0->Fill(kkk, jphi, 1.);
4953         }
4954       }
4955     }
4956   }
4957   DefzDrecosignalHF42DF->Divide(DefzDrecosignalHF42D, DefzDrecosignalHF42D0, 1, 1, "B");  // average A
4958   //    DefzDrecosignalHF1->Sumw2();
4959   gPad->SetGridy();
4960   gPad->SetGridx();  //      gPad->SetLogz();
4961   DefzDrecosignalHF42DF->SetMarkerStyle(20);
4962   DefzDrecosignalHF42DF->SetMarkerSize(0.4);
4963   DefzDrecosignalHF42DF->GetZaxis()->SetLabelSize(0.08);
4964   DefzDrecosignalHF42DF->SetXTitle("<D>_depth       #eta  \b");
4965   DefzDrecosignalHF42DF->SetYTitle("      #phi \b");
4966   DefzDrecosignalHF42DF->SetZTitle("<D>_depth \b");
4967   DefzDrecosignalHF42DF->SetMarkerColor(2);
4968   DefzDrecosignalHF42DF->SetLineColor(
4969       0);  //      DefzDrecosignalHF42DF->SetMaximum(1.000);  //      DefzDrecosignalHF42DF->SetMinimum(1.0);
4970   DefzDrecosignalHF42DF->Draw("COLZ");
4971   /////////////////
4972   c1x0->Update();
4973   c1x0->Print("DrecosignalGeneralD2PhiSymmetryHF.png");
4974   c1x0->Clear();
4975   // clean-up
4976   if (DefzDrecosignalHF42D)
4977     delete DefzDrecosignalHF42D;
4978   if (DefzDrecosignalHF42D0)
4979     delete DefzDrecosignalHF42D0;
4980   if (DefzDrecosignalHF42DF)
4981     delete DefzDrecosignalHF42DF;
4982   //====================================================================== 1D plot: D vs phi , averaged over depthfs & eta
4983   //======================================================================
4984   //cout<<"      1D plot: D vs phi , averaged over depthfs & eta *****" <<endl;
4985   c1x1->Clear();
4986   /////////////////
4987   c1x1->Divide(1, 1);
4988   c1x1->cd(1);
4989   TH1F* DefzDrecosignalHF41D = new TH1F("DefzDrecosignalHF41D", "", nphi, 0., 72.);
4990   TH1F* DefzDrecosignalHF41D0 = new TH1F("DefzDrecosignalHF41D0", "", nphi, 0., 72.);
4991   TH1F* DefzDrecosignalHF41DF = (TH1F*)DefzDrecosignalHF41D0->Clone("DefzDrecosignalHF41DF");
4992 
4993   for (int jphi = 0; jphi < nphi; jphi++) {
4994     for (int jeta = 0; jeta < neta; jeta++) {
4995       for (int i = 0; i < ndepth; i++) {
4996         double ccc1 = recosignalvarianceHF[i][jeta][jphi];
4997         if (arecosignalHF[i][jeta][jphi] > 0.) {
4998           DefzDrecosignalHF41D->Fill(jphi, ccc1);
4999           DefzDrecosignalHF41D0->Fill(jphi, 1.);
5000         }
5001       }
5002     }
5003   }
5004   //     DefzDrecosignalHF41D->Sumw2();DefzDrecosignalHF41D0->Sumw2();
5005 
5006   DefzDrecosignalHF41DF->Divide(
5007       DefzDrecosignalHF41D, DefzDrecosignalHF41D0, 1, 1, "B");  // R averaged over depthfs & eta
5008   DefzDrecosignalHF41D0->Sumw2();
5009   //    for (int jphi=1;jphi<73;jphi++) {DefzDrecosignalHF41DF->SetBinError(jphi,0.01);}
5010   gPad->SetGridy();
5011   gPad->SetGridx();  //      gPad->SetLogz();
5012   DefzDrecosignalHF41DF->SetMarkerStyle(20);
5013   DefzDrecosignalHF41DF->SetMarkerSize(1.4);
5014   DefzDrecosignalHF41DF->GetZaxis()->SetLabelSize(0.08);
5015   DefzDrecosignalHF41DF->SetXTitle("#phi  \b");
5016   DefzDrecosignalHF41DF->SetYTitle("  <D> \b");
5017   DefzDrecosignalHF41DF->SetZTitle("<D>_PHI  - AllDepthfs \b");
5018   DefzDrecosignalHF41DF->SetMarkerColor(4);
5019   DefzDrecosignalHF41DF->SetLineColor(
5020       4);  //  DefzDrecosignalHF41DF->SetMinimum(0.8);     DefzDrecosignalHF41DF->SetMinimum(-0.015);
5021   DefzDrecosignalHF41DF->Draw("Error");
5022   /////////////////
5023   c1x1->Update();
5024   c1x1->Print("DrecosignalGeneralD1PhiSymmetryHF.png");
5025   c1x1->Clear();
5026   // clean-up
5027   if (DefzDrecosignalHF41D)
5028     delete DefzDrecosignalHF41D;
5029   if (DefzDrecosignalHF41D0)
5030     delete DefzDrecosignalHF41D0;
5031   if (DefzDrecosignalHF41DF)
5032     delete DefzDrecosignalHF41DF;
5033   //========================================================================================== 14
5034   //======================================================================
5035   //======================================================================1D plot: D vs phi , different eta,  depth=1
5036   //cout<<"      1D plot: D vs phi , different eta,  depth=1 *****" <<endl;
5037   c3x5->Clear();
5038   /////////////////
5039   c3x5->Divide(3, 5);
5040   c3x5->cd(1);
5041   int kcountHFpositivedirectionRecosignalD1 = 1;
5042   TH1F* h2CeffHFpositivedirectionRecosignalD1 = new TH1F("h2CeffHFpositivedirectionRecosignalD1", "", nphi, 0., 72.);
5043 
5044   for (int jeta = 0; jeta < njeta; jeta++) {
5045     // positivedirectionRecosignalD:
5046     if (jeta - 41 >= 0) {
5047       //         for (int i=0;i<ndepth;i++) {
5048       // depth=1
5049       for (int i = 0; i < 1; i++) {
5050         TH1F* HFpositivedirectionRecosignalD1 = (TH1F*)h2CeffHFpositivedirectionRecosignalD1->Clone("twod1");
5051 
5052         float ccctest = 0;  // to avoid empty massive elements
5053         for (int jphi = 0; jphi < nphi; jphi++) {
5054           double ccc1 = recosignalvarianceHF[i][jeta][jphi];
5055           if (arecosignalHF[i][jeta][jphi] > 0.) {
5056             HFpositivedirectionRecosignalD1->Fill(jphi, ccc1);
5057             ccctest = 1.;  //HFpositivedirectionRecosignalD1->SetBinError(i,0.01);
5058           }
5059         }  // for jphi
5060         if (ccctest > 0.) {
5061           //cout<<"1414       kcountHFpositivedirectionRecosignalD1   =     "<<kcountHFpositivedirectionRecosignalD1  <<"   jeta-41=     "<< jeta-41 <<endl;
5062           c3x5->cd(kcountHFpositivedirectionRecosignalD1);
5063           HFpositivedirectionRecosignalD1->SetMarkerStyle(20);
5064           HFpositivedirectionRecosignalD1->SetMarkerSize(0.4);
5065           HFpositivedirectionRecosignalD1->GetYaxis()->SetLabelSize(0.04);
5066           HFpositivedirectionRecosignalD1->SetXTitle("HFpositivedirectionRecosignalD1 \b");
5067           HFpositivedirectionRecosignalD1->SetMarkerColor(2);
5068           HFpositivedirectionRecosignalD1->SetLineColor(0);
5069           gPad->SetGridy();
5070           gPad->SetGridx();
5071           //       gPad->SetLogy();
5072           if (kcountHFpositivedirectionRecosignalD1 == 1)
5073             HFpositivedirectionRecosignalD1->SetXTitle("D for HF+ jeta = 28; depth = 1 \b");
5074           if (kcountHFpositivedirectionRecosignalD1 == 2)
5075             HFpositivedirectionRecosignalD1->SetXTitle("D for HF+ jeta = 29; depth = 1 \b");
5076           if (kcountHFpositivedirectionRecosignalD1 == 3)
5077             HFpositivedirectionRecosignalD1->SetXTitle("D for HF+ jeta = 30; depth = 1 \b");
5078