PWG4/GammaConv/AliGammaConversionHistograms.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: Ana Marin, Kathrin Koch, Kenneth Aamodt                        *
   5  * Version 1.1                                                            *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 ////////////////////////////////////////////////
  17 //---------------------------------------------
  18 // Class used to do analysis on conversion pairs
  19 //---------------------------------------------
  20 ////////////////////////////////////////////////
  21
  22 #include "AliGammaConversionHistograms.h"
  23 #include "TMath.h"
  24 #include "TObjString.h"
  25 #include "TMap.h"
  26 #include "TList.h"
  27 #include "TH1F.h"
  28 #include "TH2F.h"
  29
  30
  31 using namespace std;
  32
  33 ClassImp(AliGammaConversionHistograms)
  34
  35
  36 AliGammaConversionHistograms::AliGammaConversionHistograms() :
  37   fHistogramMap(new TMap()),
  38   fNPhiIndex(0),
  39   fNRIndex(0),
  40   fNZIndex(0),
  41 //  fRBinLimits(0),
  42 //  fZBinLimits(0),
  43   fMinRadius(0.),
  44   fMaxRadius(0.),
  45   fDeltaR(0.),
  46   fMinPhi(0.),
  47   fMaxPhi(0.),
  48   fDeltaPhi(0.),
  49   fMappingContainer(NULL),
  50   fBackgroundContainer(NULL),
  51   fDebugContainer(NULL),
  52   fResolutionContainer(NULL),
  53   fMatchContainer(NULL),
  54   fESDContainer(NULL),
  55   fMCContainer(NULL),
  56   fTableContainer(NULL),
  57   fOtherContainer(NULL)
  58 {
  59   // see header file for documenation
  60   for(Int_t i=0;i<7;i++){
  61     fRBinLimits[i]=0.;
  62   }
  63   for(Int_t i=0;i<6;i++){
  64     fZBinLimits[i]=0.;
  65   }
  66 }
  67
  68
  69 AliGammaConversionHistograms::AliGammaConversionHistograms(const AliGammaConversionHistograms & original) :
  70   fHistogramMap(original.fHistogramMap),
  71   fNPhiIndex(original.fNPhiIndex),
  72   fNRIndex(original.fNRIndex),
  73   fNZIndex(original.fNZIndex),
  74   //  fRBinLimits(original.fRBinLimits),
  75   //  fZBinLimits(original.fZBinLimits),
  76   fMinRadius(original.fMinRadius),
  77   fMaxRadius(original.fMaxRadius),
  78   fDeltaR(original.fDeltaR),
  79   fMinPhi(original.fMinPhi),
  80   fMaxPhi(original.fMaxPhi),
  81   fDeltaPhi(original.fDeltaPhi),
  82   fMappingContainer(original.fMappingContainer),
  83   fBackgroundContainer(original.fBackgroundContainer),
  84   fDebugContainer(original.fDebugContainer),
  85   fResolutionContainer(original.fResolutionContainer),
  86   fMatchContainer(original.fMatchContainer),
  87   fESDContainer(original.fESDContainer),
  88   fMCContainer(original.fMCContainer),
  89   fTableContainer(original.fTableContainer),
  90   fOtherContainer(original.fOtherContainer)
  91 {
  92   //see header file for documentation
  93   for(Int_t i=0;i<7;i++){
  94     fRBinLimits[i]= original.fRBinLimits[i];
  95   }
  96   for(Int_t i=0;i<6;i++){
  97     fZBinLimits[i]=original.fZBinLimits[i];
  98   }
  99 }
 100
 101
 102 AliGammaConversionHistograms & AliGammaConversionHistograms::operator = (const AliGammaConversionHistograms & /*original*/)
 103 {
 104   // assignment operator
 105   return *this;
 106 }
 107
 108
 109 AliGammaConversionHistograms::~AliGammaConversionHistograms() {
 110   //destructor
 111
 112
 113 }
 114
 115 void AliGammaConversionHistograms::AddHistogram(TString histogramName, TString histogramTitle, Int_t nXBins, Double_t firstX,Double_t lastX,TString xAxisTitle, TString yAxisTitle){
 116   // see header file for documentation
 117   TH1F *tmp = new TH1F(histogramName, histogramTitle,nXBins,firstX,lastX);
 118   tmp->GetXaxis()->SetTitle(xAxisTitle);
 119   tmp->GetYaxis()->SetTitle(yAxisTitle);
 120   TObjString* tobjstring = new TObjString(histogramName.Data());
 121   fHistogramMap->Add((TObject*)tobjstring,(TObject*)tmp);
 122 }
 123
 124 void AliGammaConversionHistograms::AddHistogram(TString histogramName, TString histogramTitle, Int_t nXBins, Double_t firstX, Double_t lastX, Int_t nYBins, Double_t firstY, Double_t lastY, TString xAxisTitle, TString yAxisTitle){
 125   // see header file for documentation
 126   TH2F *tmp = new TH2F(histogramName, histogramTitle,nXBins,firstX,lastX,nYBins,firstY,lastY);
 127   tmp->GetXaxis()->SetTitle(xAxisTitle);
 128   tmp->GetYaxis()->SetTitle(yAxisTitle);
 129   TObjString *tobjstring = new TObjString(histogramName.Data());
 130   fHistogramMap->Add((TObject*)tobjstring,(TObject*)tmp);
 131 }
 132
 133 void AliGammaConversionHistograms::AddTable(TString tableName,TString tableTitle,Int_t nXBins,const char * axesLabel[]){
 134   //see header file for documentation
 135
 136   TH1F *tmp = new TH1F(tableName,tableTitle,nXBins,0,nXBins);
 137   for(Int_t xbin=1; xbin<=nXBins; xbin++){
 138     tmp->GetXaxis()->SetBinLabel(xbin,axesLabel[xbin-1]);
 139   }
 140   tmp->SetStats(0);
 141
 142   TObjString *tobjstring = new TObjString(tableName.Data());
 143   fHistogramMap->Add((TObject*)tobjstring,(TObject*)tmp);
 144 }
 145
 146 void AliGammaConversionHistograms::FillTable(TString tableName,Double_t xValue) const {
 147   //see header file for documentation
 148   TH1 *tmp = (TH1*)fHistogramMap->GetValue(tableName.Data());
 149   if(tmp){
 150     tmp->Fill(xValue);
 151   }
 152 }
 153
 154 void AliGammaConversionHistograms::FillHistogram(TString histogramName, Double_t xValue) const{
 155   //see header file for documentation
 156   TH1 *tmp = (TH1*)fHistogramMap->GetValue(histogramName.Data());
 157   if(tmp){
 158     tmp->Fill(xValue);
 159   }
 160 }
 161
 162 void AliGammaConversionHistograms::FillHistogram(TString histogramName, Double_t xValue, Double_t yValue) const{
 163   //see header file for documentation
 164   TH1 *tmp = (TH1*)fHistogramMap->GetValue(histogramName.Data());
 165   if(tmp){
 166     tmp->Fill(xValue, yValue);
 167   }
 168 }
 169
 170 void AliGammaConversionHistograms::GetOutputContainer(TList *fOutputContainer){
 171   //checking if the container is alrerady created
 172
 173   if(fOutputContainer == NULL){
 174     cout<<"WARNING: GetOutputContainer: output container object is NULL"<<endl;
 175     return;
 176   }
 177
 178   if(fHistogramMap != NULL){
 179     TIter iter(fHistogramMap);
 180     TObjString *histogramName;
 181     while ((histogramName = (TObjString*) iter.Next())) {
 182       TString histogramString = histogramName->GetString();
 183       if(histogramString.Contains("Mapping")){// means it should be put in the mapping folder
 184         if(fMappingContainer == NULL){
 185           fMappingContainer = new TList();
 186           fMappingContainer->SetName("Mapping histograms");
 187         }
 188         if(fMappingContainer != NULL){
 189           fMappingContainer->Add((TH1*)fHistogramMap->GetValue(histogramString.Data()));
 190         }
 191       }
 192       else if(histogramString.Contains("Background")){// means it should be put in the background folder
 193         if(fBackgroundContainer == NULL){
 194           fBackgroundContainer = new TList();
 195           fBackgroundContainer->SetName("Background histograms");
 196         }
 197         if(fBackgroundContainer != NULL){
 198           fBackgroundContainer->Add((TH1*)fHistogramMap->GetValue(histogramString.Data()));
 199         }
 200       }
 201       else if(histogramString.Contains("Debug")){// means it should be put in the debug folder
 202         if(fDebugContainer == NULL){
 203           fDebugContainer = new TList();
 204           fDebugContainer->SetName("Debug histograms");
 205         }
 206         if(fDebugContainer != NULL){
 207           fDebugContainer->Add((TH1*)fHistogramMap->GetValue(histogramString.Data()));
 208         }
 209       }
 210       else if(histogramString.Contains("Resolution")){// means it should be put in the resolution folder
 211         if(fResolutionContainer == NULL){
 212           fResolutionContainer = new TList();
 213           fResolutionContainer->SetName("Resolution histograms");
 214         }
 215         if(fResolutionContainer != NULL){
 216           fResolutionContainer->Add((TH1*)fHistogramMap->GetValue(histogramString.Data()));
 217         }
 218       }
 219       else if(histogramString.Contains("TrueConv")){// means it should be put in the true conv folder
 220         if(fMatchContainer == NULL){
 221           fMatchContainer = new TList();
 222           fMatchContainer->SetName("True conversion histograms");
 223         }
 224         if(fMatchContainer != NULL){
 225           fMatchContainer->Add((TH1*)fHistogramMap->GetValue(histogramString.Data()));
 226         }
 227       }
 228       else if(histogramString.Contains("ESD")){// means it should be put in the ESD folder
 229         if(fESDContainer == NULL){
 230           fESDContainer = new TList();
 231           fESDContainer->SetName("ESD histograms");
 232         }
 233         if(fESDContainer != NULL){
 234           fESDContainer->Add((TH1*)fHistogramMap->GetValue(histogramString.Data()));
 235         }
 236       }
 237       else if(histogramString.Contains("MC")){// means it should be put in the MC folder
 238         if(fMCContainer == NULL){
 239           fMCContainer = new TList();
 240           fMCContainer->SetName("MC histograms");
 241         }
 242         if(fMCContainer != NULL){
 243           fMCContainer->Add((TH1*)fHistogramMap->GetValue(histogramString.Data()));
 244         }
 245       }
 246       else if(histogramString.Contains("Table")){// means it should be put in the Table Folder
 247         if(fTableContainer == NULL){
 248            fTableContainer = new TList();
 249            fTableContainer->SetName("Tables");
 250         }
 251         if(fTableContainer != NULL){
 252            fTableContainer->Add((TH1*)fHistogramMap->GetValue(histogramString.Data()));
 253         }
 254       }
 255       else{
 256         if(fOtherContainer == NULL){
 257           fOtherContainer = new TList();
 258           fOtherContainer->SetName("Other histograms");
 259         }
 260         if(fOtherContainer != NULL){
 261           fOtherContainer->Add((TH1*)fHistogramMap->GetValue(histogramString.Data()));
 262         }
 263       }
 264       histogramName = NULL;
 265     } // end while
 266     if(fMappingContainer != NULL){
 267       fOutputContainer->Add(fMappingContainer);
 268     }
 269     if(fBackgroundContainer != NULL){
 270       fOutputContainer->Add(fBackgroundContainer);
 271     }
 272     if(fDebugContainer != NULL){
 273       fOutputContainer->Add(fDebugContainer);
 274     }
 275     if(fResolutionContainer != NULL){
 276       fOutputContainer->Add(fResolutionContainer);
 277     }
 278     if(fMatchContainer != NULL){
 279       fOutputContainer->Add(fMatchContainer);
 280     }
 281     if(fESDContainer != NULL){
 282       fOutputContainer->Add(fESDContainer);
 283     }
 284     if(fMCContainer != NULL){
 285       fOutputContainer->Add(fMCContainer);
 286     }
 287     if(fTableContainer !=  NULL){
 288        fOutputContainer->Add(fTableContainer);
 289     }
 290     if(fOtherContainer != NULL){
 291       fOutputContainer->Add(fOtherContainer);
 292     }
 293   }
 294 }
 295
 296 Int_t AliGammaConversionHistograms::GetRBin(Double_t radius) const{
 297   // see header file for documentation
 298   Int_t iResult=0;
 299 //   if(fDeltaR>0){
 300 //     iResult = (Int_t)((radius - fMinRadius)/fDeltaR);
 301 //   }
 302   for(Int_t i=0;i<fNRIndex;i++){
 303     //    cout<<"Test-limits::"<< fRBinLimits[i]<<endl;
 304     if( radius>=fRBinLimits[i] && radius<fRBinLimits[i+1] ){
 305       iResult=i;
 306     }
 307   }
 308   return iResult;
 309 }
 310
 311 Int_t AliGammaConversionHistograms::GetZBin(Double_t zPos) const{
 312   // see header file for documentation
 313   Int_t iResult=0;
 314
 315   for(Int_t i=0;i<fNZIndex;i++){
 316     //    cout<<"Test-limits::"<< fZBinLimits[i]<<endl;
 317     if( TMath::Abs(zPos)>=fZBinLimits[i] && TMath::Abs(zPos)<fZBinLimits[i+1] ){
 318       iResult=i;
 319     }
 320   }
 321   return iResult;
 322 }
 323
 324
 325
 326 Int_t AliGammaConversionHistograms::GetPhiBin(Double_t phi) const{
 327   // see header file for documentation
 328   Int_t iResult=0;
 329   if(fDeltaPhi>0){
 330     if(phi>TMath::Pi()){
 331       phi-=2*TMath::Pi();
 332     }
 333     iResult = (Int_t)((phi - fMinPhi)/fDeltaPhi);
 334   }
 335   return iResult;
 336 }
 337
 338
 339
 340 void AliGammaConversionHistograms::InitializeMappingValues(Int_t nPhiIndex, Int_t nRIndex, Int_t nBinsR, Double_t minRadius, Double_t maxRadius,Int_t nBinsPhi, Double_t minPhi, Double_t maxPhi){
 341   // Initializing the valuse for the mapping
 342
 343   fNPhiIndex = nPhiIndex;
 344   fNRIndex   = nRIndex;
 345   fNZIndex = 6;
 346
 347   //  fRBinLimits= new Double_t[8];   Kenneth: moved from pointer to fixed array
 348   fRBinLimits[0]=0.;
 349   fRBinLimits[1]=12.;
 350   fRBinLimits[2]=22.;
 351   fRBinLimits[3]=35.;
 352   fRBinLimits[4]=55.;
 353   fRBinLimits[5]=72.;
 354   fRBinLimits[6]=90.;
 355   fRBinLimits[7]=500.;
 356
 357   //  fZBinLimits= new Double_t[7]; Kenneth: moved from pointer to fixed array
 358   fZBinLimits[0]=0.;
 359   fZBinLimits[1]=15.;
 360   fZBinLimits[2]=30.;
 361   fZBinLimits[3]=50.;
 362   fZBinLimits[4]=100.;
 363   fZBinLimits[5]=200.;
 364   fZBinLimits[6]=500.;
 365
 366
 367   fMinRadius      = minRadius;
 368   fMaxRadius      = maxRadius;
 369   if(nBinsR>0 && nRIndex!=0){
 370     fDeltaR       = (fMaxRadius - fMinRadius)/nRIndex;
 371   }
 372   fMinPhi         = minPhi;
 373   fMaxPhi         = maxPhi;
 374   if(nBinsPhi>0 && nPhiIndex!=0){
 375     fDeltaPhi     = (fMaxPhi-fMinPhi)/nPhiIndex;
 376   }
 377 }
 378
 379
 380 //mapping
 381 void AliGammaConversionHistograms::AddMappingHistograms(Int_t nPhiIndex, Int_t nRIndex,Int_t nXBins, Double_t firstX, Double_t lastX, Int_t nYBins, Double_t firstY, Double_t lastY, TString xAxisTitle, TString yAxisTitle){
 382   // see header file for documentation
 383
 384   for(Int_t phi =0; phi<fNPhiIndex;phi++){
 385
 386     for(Int_t r =0; r<fNRIndex;r++){
 387
 388       // setting axis to "" changes below
 389       xAxisTitle="z [cm]";
 390       yAxisTitle="#eta";
 391
 392       //Creating the axis titles
 393       //if(xAxisTitle.Length() == 0){
 394         //xAxisTitle.Form("Phi %02d",phi);
 395          //      }
 396
 397       //if(yAxisTitle.Length() == 0){
 398         //yAxisTitle.Form("R %02d",phi);
 399                 // }
 400
 401       //MC
 402       TString nameMC="";
 403       nameMC.Form("MC_Conversion_Mapping_Phi%02d_R%02d",phi,r);
 404       TString titleMC="";
 405       titleMC.Form("Electron-Positron MC Mapping-Phi%02d-R%02d",phi,r);
 406
 407       AddHistogram(nameMC, titleMC, nXBins, firstX, lastX, nYBins, firstY, lastY, xAxisTitle, yAxisTitle);
 408
 409       //ESD
 410       TString nameESD="";
 411       nameESD.Form("ESD_Conversion_Mapping_Phi%02d_R%02d",phi,r);
 412       TString titleESD="";
 413       titleESD.Form("Electron-Positron ESD Mapping-Phi%02d-R%02d",phi,r);
 414
 415       AddHistogram(nameESD, titleESD, nXBins, firstX, lastX, nYBins, firstY, lastY, xAxisTitle, yAxisTitle);
 416     }
 417   }
 418
 419
 420   for(Int_t phi =0; phi<=nPhiIndex;phi++){
 421
 422     // setting axis to "" changes below
 423      xAxisTitle="z [cm]";
 424       yAxisTitle="#eta";
 425    //Creating the axis titles
 426     //if(xAxisTitle.Length() == 0){
 427     //  xAxisTitle.Form("Phi %02d",phi);
 428     //}
 429     //if(yAxisTitle.Length() == 0){
 430     //  yAxisTitle = "Counts";
 431     //}
 432
 433     //MC
 434     TString nameMC="";
 435     nameMC.Form("MC_Conversion_Mapping_Phi%02d",phi);
 436     TString titleMC="";
 437     titleMC.Form("Electron-Positron MC Mapping-Phi%02d",phi);
 438
 439     AddHistogram(nameMC, titleMC, nXBins, firstX, lastX, nYBins, firstY, lastY, xAxisTitle, yAxisTitle);
 440
 441     //MC
 442     TString nameESD="";
 443     nameESD.Form("ESD_Conversion_Mapping_Phi%02d",phi);
 444     TString titleESD="";
 445     titleESD.Form("Electron-Positron ESD Mapping-Phi%02d",phi);
 446
 447     AddHistogram(nameESD, titleESD, nXBins, firstX, lastX,nYBins, firstY, lastY, xAxisTitle, yAxisTitle);
 448   }
 449
 450
 451   for(Int_t r =0; r<nRIndex;r++){
 452
 453     // setting axis to "" changes below
 454     xAxisTitle="#phi";
 455       yAxisTitle="counts";
 456     //Creating the axis titles
 457     //if(xAxisTitle.Length() == 0){
 458     //  xAxisTitle.Form("R %02d",r);
 459     //}
 460     //if(yAxisTitle.Length() == 0){
 461     //  yAxisTitle = "Counts";
 462     //}
 463
 464     //MC
 465     TString nameMC="";
 466     nameMC.Form("MC_Conversion_Mapping_R%02d",r);
 467     TString titleMC="";
 468     titleMC.Form("Electron-Positron MC Mapping-R%02d",r);
 469
 470     AddHistogram(nameMC, titleMC, nXBins, firstX, lastX, nYBins, firstY, lastY, xAxisTitle, yAxisTitle);
 471
 472     //ESD
 473     TString nameESD="";
 474     nameESD.Form("ESD_Conversion_Mapping_R%02d",r);
 475     TString titleESD="";
 476     titleESD.Form("Electron-Positron ESD Mapping-R%02d",r);
 477
 478     AddHistogram(nameESD, titleESD, nXBins, firstX, lastX,nYBins, firstY, lastY, xAxisTitle, yAxisTitle);
 479
 480     //Mapping Phi in R
 481     TString nameMCPhiInR="";
 482     nameMCPhiInR.Form("MC_Conversion_Mapping_Phi_in_R_%02d",r);
 483     TString titleMCPhiInR="";
 484     titleMCPhiInR.Form("MC Mapping of Phi in R%02d",r);
 485     //    AddHistogram(nameMCPhiInR, titleMCPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
 486     AddHistogram(nameMCPhiInR, titleMCPhiInR, nXBins, -TMath::Pi(), TMath::Pi(), xAxisTitle, yAxisTitle);
 487
 488
 489     //Mapping Z in R
 490     TString nameMCZInR="";
 491     nameMCZInR.Form("MC_Conversion_Mapping_Z_in_R_%02d",r);
 492     TString titleMCZInR="";
 493     titleMCZInR.Form("MC Mapping of Z in R%02d",r);
 494     //    AddHistogram(nameMCPhiInR, titleMCPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
 495     AddHistogram(nameMCZInR, titleMCZInR, nXBins, -300, 300, xAxisTitle, yAxisTitle);
 496
 497
 498    //Mapping Phi in R Middle Pt
 499     TString nameMCMidPtPhiInR="";
 500     nameMCMidPtPhiInR.Form("MC_Conversion_Mapping_MidPt_Phi_in_R_%02d",r);
 501     TString titleMCMidPtPhiInR="";
 502     titleMCMidPtPhiInR.Form("MC Mapping Middle Pt of Phi in R%02d",r);
 503     //    AddHistogram(nameMCPhiInR, titleMCPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
 504     AddHistogram(nameMCMidPtPhiInR, titleMCMidPtPhiInR, nXBins, -TMath::Pi(), TMath::Pi(), xAxisTitle, yAxisTitle);
 505
 506
 507     //Mapping Z in R Middle Pt
 508     TString nameMCMidPtZInR="";
 509     nameMCMidPtZInR.Form("MC_Conversion_Mapping_MidPt_Z_in_R_%02d",r);
 510     TString titleMCMidPtZInR="";
 511     titleMCMidPtZInR.Form("MC Mapping Middle Pt of Z in R%02d",r);
 512     //    AddHistogram(nameMCPhiInR, titleMCPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
 513     AddHistogram(nameMCMidPtZInR, titleMCMidPtZInR, nXBins, -300, 300, xAxisTitle, yAxisTitle);
 514
 515
 516
 517
 518     //Mapping Phi in R
 519     TString nameESDPhiInR="";
 520     nameESDPhiInR.Form("ESD_Conversion_Mapping_Phi_in_R_%02d",r);
 521     TString titleESDPhiInR="";
 522     titleESDPhiInR.Form("ESD Mapping of Phi in R%02d",r);
 523     //    AddHistogram(nameESDPhiInR, titleESDPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
 524     AddHistogram(nameESDPhiInR, titleESDPhiInR, nXBins, -TMath::Pi(), TMath::Pi(), xAxisTitle, yAxisTitle);
 525
 526    //Mapping Z in R
 527     TString nameESDZInR="";
 528     nameESDZInR.Form("ESD_Conversion_Mapping_Z_in_R_%02d",r);
 529     TString titleESDZInR="";
 530     titleESDZInR.Form("ESD Mapping of Z in R%02d",r);
 531     //    AddHistogram(nameESDPhiInR, titleESDPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
 532     AddHistogram(nameESDZInR, titleESDZInR, nXBins, -300, 300, xAxisTitle, yAxisTitle);
 533
 534     //Mapping Phi in R Middle Pt
 535     TString nameESDMidPtPhiInR="";
 536     nameESDMidPtPhiInR.Form("ESD_Conversion_Mapping_MidPt_Phi_in_R_%02d",r);
 537     TString titleESDMidPtPhiInR="";
 538     titleESDMidPtPhiInR.Form("ESD Mapping Middle Pt of Phi in R%02d",r);
 539     //    AddHistogram(nameESDPhiInR, titleESDPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
 540     AddHistogram(nameESDMidPtPhiInR, titleESDMidPtPhiInR, nXBins, -TMath::Pi(), TMath::Pi(), xAxisTitle, yAxisTitle);
 541
 542    //Mapping Z in R Middle Pt
 543     TString nameESDMidPtZInR="";
 544     nameESDMidPtZInR.Form("ESD_Conversion_Mapping_MidPt_Z_in_R_%02d",r);
 545     TString titleESDMidPtZInR="";
 546     titleESDMidPtZInR.Form("ESD Mapping Middle Pt of Z in R%02d",r);
 547     //    AddHistogram(nameESDPhiInR, titleESDPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
 548     AddHistogram(nameESDMidPtZInR, titleESDMidPtZInR, nXBins, -300, 300, xAxisTitle, yAxisTitle);
 549
 550
 551
 552   }
 553
 554
 555
 556   for(Int_t z =0; z<fNZIndex;z++){
 557     //Mapping Phi in Z
 558     TString nameMCPhiInZ="";
 559     nameMCPhiInZ.Form("MC_Conversion_Mapping_Phi_in_Z_%02d",z);
 560     TString titleMCPhiInZ="";
 561     titleMCPhiInZ.Form("MC Mapping of Phi in Z%02d",z);
 562     //    AddHistogram(nameMCPhiInR, titleMCPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
 563     AddHistogram(nameMCPhiInZ, titleMCPhiInZ, nXBins, -TMath::Pi(), TMath::Pi(), xAxisTitle, yAxisTitle);
 564
 565
 566     //Mapping R in Z
 567     TString nameMCRInZ="";
 568     nameMCRInZ.Form("MC_Conversion_Mapping_R_in_Z_%02d",z);
 569     TString titleMCRInZ="";
 570     titleMCRInZ.Form("MC Mapping of R in Z%02d",z);
 571     //    AddHistogram(nameMCPhiInR, titleMCPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
 572     AddHistogram(nameMCRInZ, titleMCRInZ, nXBins, fMinRadius, fMaxRadius, xAxisTitle, yAxisTitle);
 573
 574    //Mapping Phi in Z Middle Pt
 575     TString nameMCMidPtPhiInZ="";
 576     nameMCMidPtPhiInZ.Form("MC_Conversion_Mapping_MidPt_Phi_in_Z_%02d",z);
 577     TString titleMCMidPtPhiInZ="";
 578     titleMCMidPtPhiInZ.Form("MC Mapping Middle Pt of Phi in Z%02d",z);
 579     //    AddHistogram(nameMCPhiInR, titleMCPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
 580     AddHistogram(nameMCMidPtPhiInZ, titleMCMidPtPhiInZ, nXBins, -TMath::Pi(), TMath::Pi(), xAxisTitle, yAxisTitle);
 581
 582
 583     //Mapping R in Z Middle Pt
 584     TString nameMCMidPtRInZ="";
 585     nameMCMidPtRInZ.Form("MC_Conversion_Mapping_MidPt_R_in_Z_%02d",z);
 586     TString titleMCMidPtRInZ="";
 587     titleMCMidPtRInZ.Form("MC Mapping Middle Pt of R in Z%02d",z);
 588     //    AddHistogram(nameMCPhiInR, titleMCPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
 589     AddHistogram(nameMCMidPtRInZ, titleMCMidPtRInZ, nXBins, fMinRadius, fMaxRadius, xAxisTitle, yAxisTitle);
 590
 591
 592
 593
 594     //Mapping Phi in Z
 595     TString nameESDPhiInZ="";
 596     nameESDPhiInZ.Form("ESD_Conversion_Mapping_Phi_in_Z_%02d",z);
 597     TString titleESDPhiInZ="";
 598     titleESDPhiInZ.Form("ESD Mapping of Phi in R%02d",z);
 599     //    AddHistogram(nameESDPhiInR, titleESDPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
 600     AddHistogram(nameESDPhiInZ, titleESDPhiInZ, nXBins, -TMath::Pi(), TMath::Pi(), xAxisTitle, yAxisTitle);
 601
 602    //Mapping R in Z
 603     TString nameESDRInZ="";
 604     nameESDRInZ.Form("ESD_Conversion_Mapping_R_in_Z_%02d",z);
 605     TString titleESDRInZ="";
 606     titleESDRInZ.Form("ESD Mapping of R in Z%02d",z);
 607     //    AddHistogram(nameESDPhiInR, titleESDPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
 608     AddHistogram(nameESDRInZ, titleESDRInZ, nXBins, fMinRadius, fMaxRadius, xAxisTitle, yAxisTitle);
 609
 610
 611    //Mapping Phi in Z Middle Pt
 612     TString nameESDMidPtPhiInZ="";
 613     nameESDMidPtPhiInZ.Form("ESD_Conversion_Mapping_MidPt_Phi_in_Z_%02d",z);
 614     TString titleESDMidPtPhiInZ="";
 615     titleESDMidPtPhiInZ.Form("ESD Mapping Middle Ptof Phi in R%02d",z);
 616     //    AddHistogram(nameESDPhiInR, titleESDPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
 617     AddHistogram(nameESDMidPtPhiInZ, titleESDMidPtPhiInZ, nXBins, -TMath::Pi(), TMath::Pi(), xAxisTitle, yAxisTitle);
 618
 619    //Mapping R in Z Middle Pt
 620     TString nameESDMidPtRInZ="";
 621     nameESDMidPtRInZ.Form("ESD_Conversion_Mapping_MidPt_R_in_Z_%02d",z);
 622     TString titleESDMidPtRInZ="";
 623     titleESDMidPtRInZ.Form("ESD Mapping Middle Pt of R in Z%02d",z);
 624     //    AddHistogram(nameESDPhiInR, titleESDPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
 625     AddHistogram(nameESDMidPtRInZ, titleESDMidPtRInZ, nXBins, fMinRadius, fMaxRadius, xAxisTitle, yAxisTitle);
 626
 627
 628
 629   }
 630
 631
 632
 633 }