PWG0/dNdPt/AlidNdPtAnalysisPbPb.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   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 // AlidNdPtAnalysisPbPb class.
  17 //
  18 // a. functionality:
  19 // - fills analysis control histograms
  20 // - fills generic correction matrices
  21 // - generates correction matrices
  22 //
  23 // b. data members:
  24 // - generic correction matrices
  25 // - control histograms
  26 //
  27 // Author: J.Otwinowski 04/11/2008
  28 //------------------------------------------------------------------------------
  29
  30 #include "TH1.h"
  31 #include "TH2.h"
  32 #include "TCanvas.h"
  33 #include "THnSparse.h"
  34
  35 #include "AliHeader.h"
  36 #include "AliGenEventHeader.h"
  37 #include "AliStack.h"
  38 #include "AliESDEvent.h"
  39 #include "AliMCEvent.h"
  40 #include "AliESDtrackCuts.h"
  41 #include "AliLog.h"
  42 #include "AliMultiplicity.h"
  43 #include "AliTracker.h"
  44
  45 #include "AlidNdPtEventCuts.h"
  46 #include "AlidNdPtAcceptanceCuts.h"
  47 #include "AliPhysicsSelection.h"
  48 #include "AliTriggerAnalysis.h"
  49
  50 #include "AliPWG0Helper.h"
  51 #include "AlidNdPtHelper.h"
  52 #include "AlidNdPtAnalysisPbPb.h"
  53
  54
  55 using namespace std;
  56
  57 ClassImp(AlidNdPtAnalysisPbPb)
  58
  59 //_____________________________________________________________________________
  60   AlidNdPtAnalysisPbPb::AlidNdPtAnalysisPbPb(): AlidNdPt(),
  61   fAnalysisFolder(0),
  62   fHistogramsOn(kFALSE),
  63
  64   // rec. track pt vs true track pt correlation matrix
  65   fTrackPtCorrelationMatrix(0),
  66
  67   // event level correction
  68   fGenEventMatrix(0),
  69   fTriggerEventMatrix(0),
  70   fRecEventMatrix(0),
  71
  72   //
  73   // track-event level correction
  74   //
  75   fGenTrackEventMatrix(0),
  76
  77   fTriggerTrackEventMatrix(0),
  78
  79   fRecTrackEventMatrix(0),
  80
  81   // track rec. efficiency correction (fRecPrimTrackMatrix / fGenPrimTrackMatrix)
  82   fGenTrackMatrix(0),
  83   fGenPrimTrackMatrix(0),
  84   fRecPrimTrackMatrix(0),
  85
  86   // secondary track contamination correction (fRecSecTrackMatrix / fRecTrackMatrix)
  87   fRecTrackMatrix(0),
  88   fRecSecTrackMatrix(0),
  89
  90   // multiple rec. track contamination corrections (fRecMultTrackMatrix / fRecTrackMatrix)
  91   fRecMultTrackMatrix(0),
  92
  93   // event control histograms
  94   fMCEventHist1(0),
  95   fRecEventHist1(0),
  96   fRecEventHist2(0),
  97   fRecMCEventHist1(0),
  98   fRecMCEventHist2(0),
  99
 100   // rec. pt and eta resolution w.r.t MC
 101   fRecMCTrackHist1(0),
 102
 103   //multple reconstructed tracks
 104   fMCMultRecTrackHist1(0),
 105
 106   // rec. track control histograms
 107   fRecTrackHist2(0)
 108 {
 109   // default constructor
 110   for(Int_t i=0; i<AlidNdPtHelper::kCutSteps; i++) {
 111     fMCTrackHist1[i]=0;
 112     fMCPrimTrackHist1[i]=0;
 113     fMCPrimTrackHist2[i]=0;
 114     fMCSecTrackHist1[i]=0;
 115     fRecTrackHist1[i]=0;
 116     fRecTrackMultHist1[i]=0;
 117   }
 118   Init();
 119 }
 120
 121 //_____________________________________________________________________________
 122 AlidNdPtAnalysisPbPb::AlidNdPtAnalysisPbPb(Char_t* name, Char_t* title): AlidNdPt(name,title),
 123   fAnalysisFolder(0),
 124   fHistogramsOn(kFALSE),
 125
 126   // rec. track pt vs true track pt correlation matrix
 127   fTrackPtCorrelationMatrix(0),
 128
 129   // event level correction
 130   fGenEventMatrix(0),
 131
 132   fTriggerEventMatrix(0),
 133
 134   fRecEventMatrix(0),
 135
 136   //
 137   // track-event level correction
 138   //
 139   fGenTrackEventMatrix(0),
 140
 141   fTriggerTrackEventMatrix(0),
 142
 143   fRecTrackEventMatrix(0),
 144
 145   // track rec. efficiency correction (fRecPrimTrackMatrix / fGenPrimTrackMatrix)
 146   fGenTrackMatrix(0),
 147   fGenPrimTrackMatrix(0),
 148   fRecPrimTrackMatrix(0),
 149
 150   // secondary track contamination correction (fRecSecTrackMatrix / fRecTrackMatrix)
 151   fRecTrackMatrix(0),
 152   fRecSecTrackMatrix(0),
 153
 154   // multiple rec. track contamination corrections (fRecMultTrackMatrix / fRecTrackMatrix)
 155   fRecMultTrackMatrix(0),
 156
 157   // event control histograms
 158   fMCEventHist1(0),
 159   fRecEventHist1(0),
 160   fRecEventHist2(0),
 161   fRecMCEventHist1(0),
 162   fRecMCEventHist2(0),
 163
 164   // rec. pt and eta resolution w.r.t MC
 165   fRecMCTrackHist1(0),
 166
 167   //multple reconstructed tracks
 168   fMCMultRecTrackHist1(0),
 169
 170   // rec. track control histograms
 171   fRecTrackHist2(0)
 172 {
 173   //
 174   // constructor
 175   //
 176   for(Int_t i=0; i<AlidNdPtHelper::kCutSteps; i++) {
 177     fMCTrackHist1[i]=0;
 178     fMCPrimTrackHist1[i]=0;
 179     fMCPrimTrackHist2[i]=0;
 180     fMCSecTrackHist1[i]=0;
 181     fRecTrackHist1[i]=0;
 182     fRecTrackMultHist1[i]=0;
 183   }
 184
 185   Init();
 186 }
 187
 188 //_____________________________________________________________________________
 189 AlidNdPtAnalysisPbPb::~AlidNdPtAnalysisPbPb() {
 190   //
 191   // destructor
 192   //
 193   if(fTrackPtCorrelationMatrix) delete fTrackPtCorrelationMatrix; fTrackPtCorrelationMatrix=0;
 194   //
 195   if(fGenEventMatrix) delete fGenEventMatrix; fGenEventMatrix=0;
 196   if(fTriggerEventMatrix) delete fTriggerEventMatrix; fTriggerEventMatrix=0;
 197   if(fRecEventMatrix) delete fRecEventMatrix; fRecEventMatrix=0;
 198
 199   //
 200   if(fGenTrackEventMatrix) delete fGenTrackEventMatrix; fGenTrackEventMatrix=0;
 201   if(fTriggerEventMatrix) delete fTriggerEventMatrix; fTriggerEventMatrix=0;
 202   if(fRecTrackEventMatrix) delete fRecTrackEventMatrix; fRecTrackEventMatrix=0;
 203
 204   //
 205   if(fGenTrackMatrix) delete fGenTrackMatrix; fGenTrackMatrix=0;
 206   if(fGenPrimTrackMatrix) delete fGenPrimTrackMatrix; fGenPrimTrackMatrix=0;
 207   if(fRecPrimTrackMatrix) delete fRecPrimTrackMatrix; fRecPrimTrackMatrix=0;
 208   //
 209   if(fRecTrackMatrix) delete fRecTrackMatrix; fRecTrackMatrix=0;
 210   if(fRecSecTrackMatrix) delete fRecSecTrackMatrix; fRecSecTrackMatrix=0;
 211   //
 212   if(fRecMultTrackMatrix) delete fRecMultTrackMatrix; fRecMultTrackMatrix=0;
 213   //
 214   // Control histograms
 215   //
 216   if(fMCEventHist1) delete fMCEventHist1; fMCEventHist1=0;
 217   if(fRecEventHist1) delete fRecEventHist1; fRecEventHist1=0;
 218   if(fRecEventHist2) delete fRecEventHist2; fRecEventHist2=0;
 219   if(fRecMCEventHist1) delete fRecMCEventHist1; fRecMCEventHist1=0;
 220   if(fRecMCEventHist2) delete fRecMCEventHist2; fRecMCEventHist2=0;
 221
 222   //
 223   for(Int_t i=0; i<AlidNdPtHelper::kCutSteps; i++) {
 224     if(fMCTrackHist1[i]) delete fMCTrackHist1[i]; fMCTrackHist1[i]=0;
 225     if(fMCPrimTrackHist1[i]) delete fMCPrimTrackHist1[i]; fMCPrimTrackHist1[i]=0;
 226     if(fMCPrimTrackHist2[i]) delete fMCPrimTrackHist2[i]; fMCPrimTrackHist2[i]=0;
 227     if(fMCSecTrackHist1[i]) delete fMCSecTrackHist1[i]; fMCSecTrackHist1[i]=0;
 228     if(fRecTrackHist1[i]) delete fRecTrackHist1[i]; fRecTrackHist1[i]=0;
 229     if(fRecTrackMultHist1[i]) delete fRecTrackMultHist1[i]; fRecTrackMultHist1[i]=0;
 230   }
 231   if(fRecMCTrackHist1) delete fRecMCTrackHist1; fRecMCTrackHist1=0;
 232   if(fMCMultRecTrackHist1) delete fMCMultRecTrackHist1; fMCMultRecTrackHist1=0;
 233   if(fRecTrackHist2) delete fRecTrackHist2; fRecTrackHist2=0;
 234   //
 235   if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0;
 236 }
 237
 238 //_____________________________________________________________________________
 239 void AlidNdPtAnalysisPbPb::Init(){
 240   //
 241   // Init histograms
 242   //
 243
 244   const Int_t multNbins = 47;
 245 //  const Int_t ptNbinsTrackEventCorr = 38;
 246   const Int_t ptNbins = 55;
 247   const Int_t etaNbins = 30;
 248   const Int_t zvNbins = 12;
 249
 250 //  Double_t binsMult[multNbins+1] = {-0.5, 0.5 , 1.5 , 2.5 , 3.5 , 4.5 , 5.5 , 6.5 , 7.5 , 8.5,
 251 //                                     9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5, 16.5, 17.5, 18.5,
 252 //                                   19.5,20.5, 21.5, 22.5, 23.5, 24.5, 29.5, 149.5};//for pp
 253
 254   Double_t binsMult[multNbins+1] = {-0.5, 0.5 , 1.5 , 2.5 , 3.5 , 4.5 , 5.5 , 6.5 , 7.5 , 8.5,
 255                                      9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5, 16.5, 17.5, 18.5,
 256                                      19.5,20.5, 30.5, 40.5 , 50.5 , 60.5 , 70.5 , 80.5 , 90.5 , 100.5 ,
 257                                      200.5, 300.5 , 400.5 , 500.5 ,600.5, 700.5 , 800.5 , 900.5 , 1000.5 ,
 258                                      2000.5 , 3000.5 , 4000.5 , 5000.5 , 6000.5 , 7000.5 , 8000.5 , 9000.5 , 10000.5};//forPbPb
 259
 260
 261
 262 //   Double_t binsPtTrackEventCorr[ptNbinsTrackEventCorr+1] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.65,0.7,0.75,0.8,0.85,0.9,0.95,1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2.0,2.2,2.4,2.6,3.0,4.0,6.0,10.0,16.0};
 263
 264   Double_t binsPt[ptNbins+1] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.65,0.7,0.75,0.8,0.85,0.9,0.95,1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2.0,2.2,2.4,2.6,2.8,3.0,3.2,3.4,3.6,3.8,4.0,4.5,5.0,5.5,6.0,6.5,7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0};
 265
 266   Double_t binsEta[etaNbins+1] = {-1.5,-1.4,-1.3,-1.2,-1.1,-1.0,-0.9,-0.8,-0.7,-0.6,-0.5,-0.4,-0.3,-0.2,-0.1,0.,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0,1.1,1.2,1.3,1.4,1.5};
 267
 268   Double_t binsZv[zvNbins+1] = {-30.,-25.,-20.,-15.,-10.,-5.,0.,5.,10.,15.,20.,25.,30.};
 269
 270   Int_t binsTrackEventCorrMatrix[3]={zvNbins,ptNbins,etaNbins};
 271
 272   Int_t binsTrackPtCorrelationMatrix[3]={ptNbins,ptNbins,etaNbins};
 273
 274   fTrackPtCorrelationMatrix = new THnSparseF("fTrackPtCorrelationMatrix","Pt:mcPt:mcEta",3,binsTrackPtCorrelationMatrix);
 275   fTrackPtCorrelationMatrix->SetBinEdges(0,binsPt);
 276   fTrackPtCorrelationMatrix->SetBinEdges(1,binsPt);
 277   fTrackPtCorrelationMatrix->SetBinEdges(2,binsEta);
 278   fTrackPtCorrelationMatrix->GetAxis(0)->SetTitle("Pt (GeV/c)");
 279   fTrackPtCorrelationMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");
 280   fTrackPtCorrelationMatrix->GetAxis(2)->SetTitle("mcEta");
 281   fTrackPtCorrelationMatrix->Sumw2();
 282
 283   //
 284   // Efficiency and contamination correction matrices
 285   //
 286   Int_t binsEventMatrix[2]={zvNbins,multNbins};
 287   Double_t minEventMatrix[2]={-30.,-0.5};
 288   Double_t maxEventMatrix[2]={30.,10000.5 };
 289
 290   fGenEventMatrix = new THnSparseF("fGenEventMatrix","mcZv:multMB",2,binsEventMatrix,minEventMatrix,maxEventMatrix);
 291   fGenEventMatrix->SetBinEdges(0,binsZv);
 292   fGenEventMatrix->SetBinEdges(1,binsMult);
 293   fGenEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");
 294   fGenEventMatrix->GetAxis(1)->SetTitle("multiplicity MB");
 295   fGenEventMatrix->Sumw2();
 296   //
 297   fTriggerEventMatrix = new THnSparseF("fTriggerEventMatrix","mcZv:multMB",2,binsEventMatrix,minEventMatrix,maxEventMatrix);
 298   fTriggerEventMatrix->SetBinEdges(0,binsZv);
 299   fTriggerEventMatrix->SetBinEdges(1,binsMult);
 300   fTriggerEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");
 301   fTriggerEventMatrix->GetAxis(1)->SetTitle("multiplicity MB");
 302   fTriggerEventMatrix->Sumw2();
 303   //
 304   fRecEventMatrix = new THnSparseF("fRecEventMatrix","mcZv:multMB",2,binsEventMatrix,minEventMatrix,maxEventMatrix);
 305   fRecEventMatrix->SetBinEdges(0,binsZv);
 306   fRecEventMatrix->SetBinEdges(1,binsMult);
 307   fRecEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");
 308   fRecEventMatrix->GetAxis(1)->SetTitle("multiplicity MB");
 309   fRecEventMatrix->Sumw2();
 310
 311   //
 312   // track to event corrections
 313   //
 314   fGenTrackEventMatrix = new THnSparseF("fGenTrackEventMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);
 315   fGenTrackEventMatrix->SetBinEdges(0,binsZv);
 316   fGenTrackEventMatrix->SetBinEdges(1,binsPt);
 317   fGenTrackEventMatrix->SetBinEdges(2,binsEta);
 318   fGenTrackEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");
 319   fGenTrackEventMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");
 320   fGenTrackEventMatrix->GetAxis(2)->SetTitle("mcEta");
 321   fGenTrackEventMatrix->Sumw2();
 322   //
 323   fTriggerTrackEventMatrix = new THnSparseF("fTriggerTrackEventMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);
 324   fTriggerTrackEventMatrix->SetBinEdges(0,binsZv);
 325   fTriggerTrackEventMatrix->SetBinEdges(1,binsPt);
 326   fTriggerTrackEventMatrix->SetBinEdges(2,binsEta);
 327   fTriggerTrackEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");
 328   fTriggerTrackEventMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");
 329   fTriggerTrackEventMatrix->GetAxis(2)->SetTitle("mcEta");
 330   fTriggerTrackEventMatrix->Sumw2();
 331   //
 332   fRecTrackEventMatrix = new THnSparseF("fRecTrackEventMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);
 333   fRecTrackEventMatrix->SetBinEdges(0,binsZv);
 334   fRecTrackEventMatrix->SetBinEdges(1,binsPt);
 335   fRecTrackEventMatrix->SetBinEdges(2,binsEta);
 336   fRecTrackEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");
 337   fRecTrackEventMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");
 338   fRecTrackEventMatrix->GetAxis(2)->SetTitle("mcEta");
 339   fRecTrackEventMatrix->Sumw2();
 340
 341   //
 342   // tracks correction matrices
 343   //
 344   fGenTrackMatrix = new THnSparseF("fGenTrackMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);
 345   fGenTrackMatrix->SetBinEdges(0,binsZv);
 346   fGenTrackMatrix->SetBinEdges(1,binsPt);
 347   fGenTrackMatrix->SetBinEdges(2,binsEta);
 348   fGenTrackMatrix->GetAxis(0)->SetTitle("mcZv (cm)");
 349   fGenTrackMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");
 350   fGenTrackMatrix->GetAxis(2)->SetTitle("mcEta");
 351   fGenTrackMatrix->Sumw2();
 352
 353   fGenPrimTrackMatrix = new THnSparseF("fGenPrimTrackMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);
 354   fGenPrimTrackMatrix->SetBinEdges(0,binsZv);
 355   fGenPrimTrackMatrix->SetBinEdges(1,binsPt);
 356   fGenPrimTrackMatrix->SetBinEdges(2,binsEta);
 357   fGenPrimTrackMatrix->GetAxis(0)->SetTitle("mcZv (cm)");
 358   fGenPrimTrackMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");
 359   fGenPrimTrackMatrix->GetAxis(2)->SetTitle("mcEta");
 360   fGenPrimTrackMatrix->Sumw2();
 361
 362
 363   fRecPrimTrackMatrix = new THnSparseF("fRecPrimTrackMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);
 364   fRecPrimTrackMatrix->SetBinEdges(0,binsZv);
 365   fRecPrimTrackMatrix->SetBinEdges(1,binsPt);
 366   fRecPrimTrackMatrix->SetBinEdges(2,binsEta);
 367   fRecPrimTrackMatrix->GetAxis(0)->SetTitle("mcZv (cm)");
 368   fRecPrimTrackMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");
 369   fRecPrimTrackMatrix->GetAxis(2)->SetTitle("mcEta");
 370   fRecPrimTrackMatrix->Sumw2();
 371
 372   //
 373   fRecTrackMatrix = new THnSparseF("fRecTrackMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);
 374   fRecTrackMatrix->SetBinEdges(0,binsZv);
 375   fRecTrackMatrix->SetBinEdges(1,binsPt);
 376   fRecTrackMatrix->SetBinEdges(2,binsEta);
 377   fRecTrackMatrix->GetAxis(0)->SetTitle("mcZv (cm)");
 378   fRecTrackMatrix->GetAxis(1)->SetTitle("Pt (GeV/c)");
 379   fRecTrackMatrix->GetAxis(2)->SetTitle("Eta");
 380   fRecTrackMatrix->Sumw2();
 381
 382   fRecSecTrackMatrix = new THnSparseF("fRecSecTrackMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);
 383   fRecSecTrackMatrix->SetBinEdges(0,binsZv);
 384   fRecSecTrackMatrix->SetBinEdges(1,binsPt);
 385   fRecSecTrackMatrix->SetBinEdges(2,binsEta);
 386   fRecSecTrackMatrix->GetAxis(0)->SetTitle("mcZv (cm)");
 387   fRecSecTrackMatrix->GetAxis(1)->SetTitle("Pt (GeV/c)");
 388   fRecSecTrackMatrix->GetAxis(2)->SetTitle("Eta");
 389   fRecSecTrackMatrix->Sumw2();
 390
 391   //
 392   fRecMultTrackMatrix = new THnSparseF("fRecMultTrackMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);
 393   fRecMultTrackMatrix->SetBinEdges(0,binsZv);
 394   fRecMultTrackMatrix->SetBinEdges(1,binsPt);
 395   fRecMultTrackMatrix->SetBinEdges(2,binsEta);
 396   fRecMultTrackMatrix->GetAxis(0)->SetTitle("mcZv (cm)");
 397   fRecMultTrackMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");
 398   fRecMultTrackMatrix->GetAxis(2)->SetTitle("mcEta");
 399   fRecMultTrackMatrix->Sumw2();
 400
 401   //
 402   // Control analysis histograms
 403   //
 404   Int_t binsMCEventHist1[3]={100,100,zvNbins};
 405   Double_t minMCEventHist1[3]={-0.1,-0.1,-30.};
 406   Double_t maxMCEventHist1[3]={0.1,0.1,30.};
 407   fMCEventHist1 = new THnSparseF("fMCEventHist1","mcXv:mcYv:mcZv",3,binsMCEventHist1,minMCEventHist1,maxMCEventHist1);
 408   fMCEventHist1->SetBinEdges(2,binsZv);
 409   fMCEventHist1->GetAxis(0)->SetTitle("mcXv (cm)");
 410   fMCEventHist1->GetAxis(1)->SetTitle("mcYv (cm)");
 411   fMCEventHist1->GetAxis(2)->SetTitle("mcZv (cm)");
 412   fMCEventHist1->Sumw2();
 413
 414   //
 415   Int_t binsRecEventHist1[3]={100,100,zvNbins};
 416   Double_t minRecEventHist1[3]={-3.,-3.,-30.};
 417   Double_t maxRecEventHist1[3]={3.,3.,30.};
 418
 419   fRecEventHist1 = new THnSparseF("fRecEventHist1","Xv:Yv:Zv",3,binsRecEventHist1,minRecEventHist1,maxRecEventHist1);
 420   fRecEventHist1->SetBinEdges(2,binsZv);
 421   fRecEventHist1->GetAxis(0)->SetTitle("Xv (cm)");
 422   fRecEventHist1->GetAxis(1)->SetTitle("Yv (cm)");
 423   fRecEventHist1->GetAxis(2)->SetTitle("Zv (cm)");
 424   fRecEventHist1->Sumw2();
 425
 426   //
 427   Int_t binsRecEventHist2[3]={zvNbins,multNbins,multNbins};
 428   Double_t minRecEventHist2[3]={-30.,-0.5,-0.5};
 429   Double_t maxRecEventHist2[3]={30.,10000.5,10000.5};
 430
 431   fRecEventHist2 = new THnSparseF("fRecEventHist2","Zv:multMB:mult",3,binsRecEventHist2,minRecEventHist2,maxRecEventHist2);
 432   fRecEventHist2->SetBinEdges(0,binsZv);
 433   fRecEventHist2->SetBinEdges(1,binsMult);
 434   fRecEventHist2->SetBinEdges(2,binsMult);
 435   fRecEventHist2->GetAxis(0)->SetTitle("Zv (cm)");
 436   fRecEventHist2->GetAxis(1)->SetTitle("multiplicity MB");
 437   fRecEventHist2->GetAxis(2)->SetTitle("multiplicity");
 438   fRecEventHist2->Sumw2();
 439
 440   //
 441   Double_t kFact = 0.1;
 442   Int_t binsRecMCEventHist1[3]={100,100,100};
 443   Double_t minRecMCEventHist1[3]={-10.0*kFact,-10.0*kFact,-10.0*kFact};
 444   Double_t maxRecMCEventHist1[3]={10.0*kFact,10.0*kFact,10.0*kFact};
 445
 446   fRecMCEventHist1 = new THnSparseF("fRecMCEventHist1","Xv-mcXv:Yv-mcYv:Zv-mcZv",3,binsRecMCEventHist1,minRecMCEventHist1,maxRecMCEventHist1);
 447   fRecMCEventHist1->SetBinEdges(2,binsZv);
 448   fRecMCEventHist1->GetAxis(0)->SetTitle("Xv-mcXv (cm)");
 449   fRecMCEventHist1->GetAxis(1)->SetTitle("Yv-mcYv (cm)");
 450   fRecMCEventHist1->GetAxis(2)->SetTitle("Zv-mcZv (cm)");
 451   fRecMCEventHist1->Sumw2();
 452
 453   //
 454   Int_t binsRecMCEventHist2[3]={100,100,multNbins};
 455   Double_t minRecMCEventHist2[3]={-10.0*kFact,-10.0*kFact,-0.5};
 456   Double_t maxRecMCEventHist2[3]={10.0*kFact,10.0*kFact,10000.5};
 457
 458   fRecMCEventHist2 = new THnSparseF("fRecMCEventHist2","Xv-mcXv:Zv-mcZv:mult",3,binsRecMCEventHist2,minRecMCEventHist2,maxRecMCEventHist2);
 459   fRecMCEventHist2->SetBinEdges(2,binsMult);
 460   fRecMCEventHist2->GetAxis(0)->SetTitle("Xv-mcXv (cm)");
 461   fRecMCEventHist2->GetAxis(1)->SetTitle("Zv-mcZv (cm)");
 462   fRecMCEventHist2->GetAxis(2)->SetTitle("multiplicity");
 463   fRecMCEventHist2->Sumw2();
 464   //
 465   char name[256];
 466   char title[256];
 467   for(Int_t i=0; i<AlidNdPtHelper::kCutSteps; i++)
 468   {
 469   // THnSparse track histograms
 470
 471   Int_t binsMCTrackHist1[3]=  {ptNbins, etaNbins, 90};
 472   Double_t minMCTrackHist1[3]={0.,-1.5,0.};
 473   Double_t maxMCTrackHist1[3]={16.,1.5,2.*TMath::Pi()};
 474   sprintf(name,"fMCTrackHist1_%d",i);
 475   sprintf(title,"mcPt:mcEta:mcPhi");
 476
 477   fMCTrackHist1[i] = new THnSparseF(name,title,3,binsMCTrackHist1,minMCTrackHist1,maxMCTrackHist1);
 478   fMCTrackHist1[i]->SetBinEdges(0,binsPt);
 479   fMCTrackHist1[i]->SetBinEdges(1,binsEta);
 480   fMCTrackHist1[i]->GetAxis(0)->SetTitle("mcPt (GeV/c)");
 481   fMCTrackHist1[i]->GetAxis(1)->SetTitle("mcEta");
 482   fMCTrackHist1[i]->GetAxis(2)->SetTitle("mcPhi (rad)");
 483   fMCTrackHist1[i]->Sumw2();
 484
 485   Int_t binsMCPrimTrackHist1[5]=  {ptNbins,etaNbins,6,20,4000};
 486   Double_t minMCPrimTrackHist1[5]={0.,-1.5,0.,0.,0.};
 487   Double_t maxMCPrimTrackHist1[5]={16.,1.5,6.,20.,4000.};
 488   sprintf(name,"fMCPrimTrackHist1_%d",i);
 489   sprintf(title,"mcPt:mcEta:pid:mech:mother");
 490
 491   fMCPrimTrackHist1[i] = new THnSparseF(name,title,5,binsMCPrimTrackHist1,minMCPrimTrackHist1,maxMCPrimTrackHist1);
 492   fMCPrimTrackHist1[i]->SetBinEdges(0,binsPt);
 493   fMCPrimTrackHist1[i]->SetBinEdges(1,binsEta);
 494   fMCPrimTrackHist1[i]->GetAxis(0)->SetTitle("mcPt (GeV/c)");
 495   fMCPrimTrackHist1[i]->GetAxis(1)->SetTitle("mcEta");
 496   fMCPrimTrackHist1[i]->GetAxis(2)->SetTitle("pid");
 497   fMCPrimTrackHist1[i]->GetAxis(3)->SetTitle("mech");
 498   fMCPrimTrackHist1[i]->GetAxis(4)->SetTitle("mother");
 499   fMCPrimTrackHist1[i]->Sumw2();
 500
 501   Int_t binsMCPrimTrackHist2[5]=  {4000,20,4000};
 502   Double_t minMCPrimTrackHist2[5]={0.,0.,0.};
 503   Double_t maxMCPrimTrackHist2[5]={4000.,20.,4000.};
 504   sprintf(name,"fMCPrimTrackHist2_%d",i);
 505   sprintf(title,"pdg:mech:mother");
 506
 507   fMCPrimTrackHist2[i] = new THnSparseF(name,title,5,binsMCPrimTrackHist2,minMCPrimTrackHist2,maxMCPrimTrackHist2);
 508   fMCPrimTrackHist2[i]->GetAxis(0)->SetTitle("pdg");
 509   fMCPrimTrackHist2[i]->GetAxis(1)->SetTitle("mech");
 510   fMCPrimTrackHist2[i]->GetAxis(2)->SetTitle("mother");
 511   fMCPrimTrackHist2[i]->Sumw2();
 512
 513   Int_t binsMCSecTrackHist1[5]=  {ptNbins,etaNbins,6,20,4000};
 514   Double_t minMCSecTrackHist1[5]={0.,-1.5,0.,0.,0.};
 515   Double_t maxMCSecTrackHist1[5]={16.,1.5,6.,20.,4000.};
 516   sprintf(name,"fMCSecTrackHist1_%d",i);
 517   sprintf(title,"mcPt:mcEta:mcPhi:pid:mech:mother");
 518
 519   fMCSecTrackHist1[i] = new THnSparseF(name,title,5,binsMCSecTrackHist1,minMCSecTrackHist1,maxMCSecTrackHist1);
 520   fMCSecTrackHist1[i]->SetBinEdges(0,binsPt);
 521   fMCSecTrackHist1[i]->SetBinEdges(1,binsEta);
 522   fMCSecTrackHist1[i]->GetAxis(0)->SetTitle("mcPt (GeV/c)");
 523   fMCSecTrackHist1[i]->GetAxis(1)->SetTitle("mcEta");
 524   fMCSecTrackHist1[i]->GetAxis(2)->SetTitle("pid");
 525   fMCSecTrackHist1[i]->GetAxis(3)->SetTitle("mech");
 526   fMCSecTrackHist1[i]->GetAxis(4)->SetTitle("mother");
 527   fMCSecTrackHist1[i]->Sumw2();
 528
 529   Int_t binsRecTrackHist1[3]={ptNbins,etaNbins,90};
 530   Double_t minRecTrackHist1[3]={0.,-1.5,0.};
 531   Double_t maxRecTrackHist1[3]={16.,1.5,2.*TMath::Pi()};
 532   sprintf(name,"fRecTrackHist1_%d",i);
 533   sprintf(title,"Pt:Eta:Phi");
 534   fRecTrackHist1[i] = new THnSparseF(name,title,3,binsRecTrackHist1,minRecTrackHist1,maxRecTrackHist1);
 535   fRecTrackHist1[i]->SetBinEdges(0,binsPt);
 536   fRecTrackHist1[i]->SetBinEdges(1,binsEta);
 537   fRecTrackHist1[i]->GetAxis(0)->SetTitle("p_{T} (GeV/c)");
 538   fRecTrackHist1[i]->GetAxis(1)->SetTitle("#eta");
 539   fRecTrackHist1[i]->GetAxis(2)->SetTitle("#phi (rad)");
 540   fRecTrackHist1[i]->Sumw2();
 541
 542   //
 543   Int_t binsRecTrackMultHist1[2]={ptNbins,multNbins};
 544   Double_t minRecTrackMultHist1[2]={0.,-0.5};
 545   Double_t maxRecTrackMultHist1[2]={16.,10000.5};
 546   sprintf(name,"fRecTrackMultHist_%d",i);
 547   sprintf(title,"Pt:Mult");
 548   fRecTrackMultHist1[i] = new THnSparseF(name,title,2,binsRecTrackMultHist1,minRecTrackMultHist1,maxRecTrackMultHist1);
 549   fRecTrackMultHist1[i]->SetBinEdges(0,binsPt);
 550   fRecTrackMultHist1[i]->SetBinEdges(1,binsMult);
 551   fRecTrackMultHist1[i]->GetAxis(0)->SetTitle("Pt (GeV/c)");
 552   fRecTrackMultHist1[i]->GetAxis(1)->SetTitle("multiplicity");
 553   fRecTrackMultHist1[i]->Sumw2();
 554   }
 555
 556   Int_t binsRecMCTrackHist1[4] = {ptNbins,etaNbins,100,100};
 557   Double_t minRecMCTrackHist1[4]={0.,-1.5,-0.5,-0.5};
 558   Double_t maxRecMCTrackHist1[4]={16.,1.5,0.5,0.5};
 559
 560   sprintf(name,"fRecMCTrackHist1");
 561   sprintf(title,"mcPt:mcEta:(Pt-mcPt)/mcPt:(Eta-mcEta)");
 562   fRecMCTrackHist1 = new THnSparseF(name,title,4,binsRecMCTrackHist1,minRecMCTrackHist1,maxRecMCTrackHist1);
 563   fRecMCTrackHist1->SetBinEdges(0,binsPt);
 564   fRecMCTrackHist1->SetBinEdges(1,binsEta);
 565   fRecMCTrackHist1->GetAxis(0)->SetTitle("mcPt (GeV/c)");
 566   fRecMCTrackHist1->GetAxis(1)->SetTitle("mcEta");
 567   fRecMCTrackHist1->GetAxis(2)->SetTitle("(Pt-mcPt)/mcPt");
 568   fRecMCTrackHist1->GetAxis(3)->SetTitle("Eta-mcEta");
 569
 570   Int_t binsMCMultRecTrackHist1[3] = {ptNbins,etaNbins,6};
 571   Double_t minMCMultRecTrackHist1[3]={0.,-1.5,0.};
 572   Double_t maxMCMultRecTrackHist1[3]={16.,1.5,6.};
 573   sprintf(name,"fMCMultRecTrackHist1");
 574   sprintf(title,"mcPt:mcEta:pid");
 575   fMCMultRecTrackHist1 = new THnSparseF(name,title,3,binsMCMultRecTrackHist1,minMCMultRecTrackHist1,maxMCMultRecTrackHist1);
 576   fMCMultRecTrackHist1->SetBinEdges(0,binsPt);
 577   fMCMultRecTrackHist1->SetBinEdges(1,binsEta);
 578   fMCMultRecTrackHist1->GetAxis(0)->SetTitle("mcPt (GeV/c)");
 579   fMCMultRecTrackHist1->GetAxis(1)->SetTitle("mcEta");
 580   fMCMultRecTrackHist1->GetAxis(2)->SetTitle("pid");
 581
 582   //nClust:chi2PerClust:pt:eta:phi
 583   Int_t binsRecTrackHist2[5]={160,100,ptNbins,etaNbins,90};
 584   Double_t minRecTrackHist2[5]={0., 0., 0., -1.5, 0.};
 585   Double_t maxRecRecTrackHist2[5]={160.,10., 16., 1.5, 2.*TMath::Pi()};
 586
 587   fRecTrackHist2 = new THnSparseF("fRecTrackHist2","nClust:chi2PerClust:pt:eta:phi",5,binsRecTrackHist2,minRecTrackHist2,maxRecRecTrackHist2);
 588   fRecTrackHist2->SetBinEdges(2,binsPt);
 589   fRecTrackHist2->SetBinEdges(3,binsEta);
 590   fRecTrackHist2->GetAxis(0)->SetTitle("nClust");
 591   fRecTrackHist2->GetAxis(1)->SetTitle("chi2PerClust");
 592   fRecTrackHist2->GetAxis(2)->SetTitle("p_{T} (GeV/c)");
 593   fRecTrackHist2->GetAxis(3)->SetTitle("#eta");
 594   fRecTrackHist2->GetAxis(4)->SetTitle("#phi (rad)");
 595   fRecTrackHist2->Sumw2();
 596
 597   // init folder
 598   fAnalysisFolder = CreateFolder("folderdNdPt","Analysis dNdPt Folder");
 599 }
 600
 601 //_____________________________________________________________________________
 602 void AlidNdPtAnalysisPbPb::Process(AliESDEvent *const esdEvent, AliMCEvent *const mcEvent)
 603 {
 604   //
 605   // Process real and/or simulated events
 606   //
 607   if(!esdEvent) {
 608     AliDebug(AliLog::kError, "esdEvent not available");
 609     return;
 610   }
 611
 612
 613   // get selection cuts
 614   AlidNdPtEventCuts *evtCuts = GetEventCuts();
 615   AlidNdPtAcceptanceCuts *accCuts = GetAcceptanceCuts();
 616   AliESDtrackCuts *esdTrackCuts = GetTrackCuts();
 617
 618   if(!evtCuts || !accCuts  || !esdTrackCuts) {
 619     AliDebug(AliLog::kError, "cuts not available");
 620     return;
 621   }
 622
 623   // trigger selection
 624   Bool_t isEventTriggered = kTRUE;
 625   AliPhysicsSelection *trigSel = NULL;
 626   AliTriggerAnalysis *trigAna = NULL;
 627
 628   if(evtCuts->IsTriggerRequired())
 629   {
 630     //
 631     trigSel = GetPhysicsTriggerSelection();
 632     if(!trigSel) {
 633       printf("cannot get trigSel \n");
 634       return;
 635     }
 636
 637     //
 638     if(IsUseMCInfo())
 639     {
 640       trigSel->SetAnalyzeMC();
 641
 642
 643         isEventTriggered = trigSel->IsCollisionCandidate(esdEvent);
 644
 645         if(GetTrigger() == AliTriggerAnalysis::kV0AND)
 646         {
 647           trigAna = trigSel->GetTriggerAnalysis();
 648           if(!trigAna)
 649             return;
 650
 651           isEventTriggered = trigAna->IsOfflineTriggerFired(esdEvent, GetTrigger());
 652         }//if(GetTrigger() == AliTriggerAnalysis::kV0AND)
 653      }//if(IsUseMCInfo())
 654   }//if(evtCuts->IsTriggerRequired())
 655
 656
 657
 658   // use MC information
 659   AliHeader* header = 0;
 660   AliGenEventHeader* genHeader = 0;
 661   AliStack* stack = 0;
 662   TArrayF vtxMC(3);
 663
 664   Int_t multMCTrueTracks = 0;
 665   if(IsUseMCInfo())
 666   {
 667     //
 668     if(!mcEvent) {
 669       AliDebug(AliLog::kError, "mcEvent not available");
 670       return;
 671     }
 672     // get MC event header
 673     header = mcEvent->Header();
 674     if (!header) {
 675       AliDebug(AliLog::kError, "Header not available");
 676       return;
 677     }
 678     // MC particle stack
 679     stack = mcEvent->Stack();
 680     if (!stack) {
 681       AliDebug(AliLog::kError, "Stack not available");
 682       return;
 683     }
 684
 685     // get MC vertex
 686     genHeader = header->GenEventHeader();
 687     if (!genHeader) {
 688       AliDebug(AliLog::kError, "Could not retrieve genHeader from Header");
 689       return;
 690     }
 691     genHeader->PrimaryVertex(vtxMC);
 692
 693     Double_t vMCEventHist1[3]={vtxMC[0],vtxMC[1],vtxMC[2]};
 694     fMCEventHist1->Fill(vMCEventHist1);
 695
 696     // multipliticy of all MC primary tracks
 697     // in Zv, pt and eta ranges)
 698     multMCTrueTracks = AlidNdPtHelper::GetMCTrueTrackMult(mcEvent,evtCuts,accCuts);
 699
 700   } // end bUseMC
 701
 702   // get reconstructed vertex
 703   const AliESDVertex* vtxESD = 0;
 704   Bool_t isRecVertex = kTRUE;
 705   if(evtCuts->IsRecVertexRequired())
 706   {
 707 //    Bool_t bRedoTPCVertex = evtCuts->IsRedoTPCVertex();
 708     //Bool_t bUseConstraints = evtCuts->IsUseBeamSpotConstraint();
 709     //vtxESD = AlidNdPtHelper::GetVertex(esdEvent,evtCuts,accCuts,esdTrackCuts,GetAnalysisMode(),kFALSE,bRedoTPCVertex,bUseConstraints);
 710     //isRecVertex = AlidNdPtHelper::TestRecVertex(vtxESD, esdEvent->GetPrimaryVertexSPD(), GetAnalysisMode(), kFALSE);
 711     if(GetAnalysisMode() == AlidNdPtHelper::kTPC) {
 712       vtxESD = esdEvent->GetPrimaryVertexTPC();
 713       //isRecVertex = AlidNdPtHelper::TestRecVertex(vtxESD, esdEvent->GetPrimaryVertexSPD(), GetAnalysisMode(), kFALSE);
 714     }
 715   }
 716
 717   Bool_t isEventOK = evtCuts->AcceptEvent(esdEvent,mcEvent,vtxESD) && isRecVertex;
 718   //printf("isEventOK %d, isEventTriggered %d \n",isEventOK, isEventTriggered);
 719   //printf("GetAnalysisMode() %d \n",GetAnalysisMode());
 720
 721   // vertex contributors
 722   Int_t multMBTracks = 0;
 723   if(GetAnalysisMode() == AlidNdPtHelper::kTPC)
 724   {
 725      if(vtxESD->GetStatus() && isRecVertex) {
 726          //multMBTracks = AlidNdPtHelper::GetTPCMBTrackMult(esdEvent,evtCuts,accCuts,esdTrackCuts);
 727          multMBTracks = vtxESD->GetNContributors();
 728      }
 729   }
 730   else {
 731     AliDebug(AliLog::kError, Form("Found analysis type %d", GetAnalysisMode()));
 732     return;
 733   }
 734
 735   TObjArray *allChargedTracks=0;
 736   //Int_t multAll=0, multAcc=0, multRec=0;
 737   Int_t multAll=0, multRec=0;
 738   Int_t *labelsAll=0, *labelsAcc=0, *labelsRec=0;
 739
 740   // check event cuts
 741   if(isEventOK && isEventTriggered)
 742   {
 743
 744     // get all charged tracks
 745     allChargedTracks = AlidNdPtHelper::GetAllChargedTracks(esdEvent,GetAnalysisMode());
 746     if(!allChargedTracks) return;
 747
 748     Int_t entries = allChargedTracks->GetEntries();
 749
 750     labelsAll = new Int_t[entries];
 751     labelsAcc = new Int_t[entries];
 752     labelsRec = new Int_t[entries];
 753     for(Int_t i=0; i<entries;++i)
 754     {
 755       AliESDtrack *track = (AliESDtrack*)allChargedTracks->At(i);
 756
 757
 758       if(!track) continue;
 759       if(track->Charge()==0) continue;
 760
 761
 762
 763       // only postive charged
 764       if(GetParticleMode() == AlidNdPtHelper::kPlus && track->Charge() < 0)
 765         continue;
 766
 767       // only negative charged
 768       if(GetParticleMode() == AlidNdPtHelper::kMinus && track->Charge() > 0)
 769         continue;
 770
 771       //
 772       FillHistograms(track,stack,AlidNdPtHelper::kAllTracks);
 773       labelsAll[multAll] = TMath::Abs(track->GetLabel());
 774
 775       multAll++;
 776
 777       if(esdTrackCuts->AcceptTrack(track) && accCuts->AcceptTrack(track)) {
 778
 779          FillHistograms(track,stack,AlidNdPtHelper::kRecTracks);
 780          labelsRec[multRec] = TMath::Abs(track->GetLabel());
 781
 782          multRec++;
 783
 784       }
 785      }//loop over entries
 786
 787
 788      // fill track multiplicity histograms
 789      //FillHistograms(allChargedTracks,labelsAll,multAll,labelsAcc,multAcc,labelsRec,multRec);
 790
 791      Double_t vRecEventHist1[3] = {vtxESD->GetXv(),vtxESD->GetYv(),vtxESD->GetZv()};
 792      fRecEventHist1->Fill(vRecEventHist1);
 793
 794      Double_t vRecEventHist2[3] = {vtxESD->GetZv(),multMBTracks,multRec};
 795      fRecEventHist2->Fill(vRecEventHist2);
 796
 797    } // triggered and event vertex
 798
 799    if(IsUseMCInfo())
 800    {
 801
 802      //Double_t vMultTrueEventMatrix[2] = { multRec, multMCTrueTracks };
 803
 804      //
 805      // event level corrections (zv,N_MB)
 806      //
 807      // all inelastic
 808      Double_t vEventMatrix[2] = {vtxMC[2],multMBTracks};
 809      fGenEventMatrix->Fill(vEventMatrix);
 810      if(isEventTriggered) fTriggerEventMatrix->Fill(vEventMatrix);
 811      if(isEventOK && isEventTriggered) fRecEventMatrix->Fill(vEventMatrix);
 812
 813      //
 814      // track-event level corrections (zv,pt,eta)
 815      //
 816      for (Int_t iMc = 0; iMc < stack->GetNtrack(); ++iMc)
 817      {
 818        TParticle* particle = stack->Particle(iMc);
 819        if (!particle)
 820        continue;
 821
 822        // only charged particles
 823        if(!particle->GetPDG()) continue;
 824        Double_t charge = particle->GetPDG()->Charge()/3.;
 825        if ( TMath::Abs(charge) < 0.001 )
 826         continue;
 827
 828        // only postive charged
 829        if(GetParticleMode() == AlidNdPtHelper::kPlus && charge < 0.)
 830         continue;
 831
 832        // only negative charged
 833        if(GetParticleMode() == AlidNdPtHelper::kMinus && charge > 0.)
 834        continue;
 835
 836        // physical primary
 837        Bool_t prim = stack->IsPhysicalPrimary(iMc);
 838        if(!prim) continue;
 839
 840        // checked accepted
 841        if(accCuts->AcceptTrack(particle))
 842        {
 843          Double_t vTrackEventMatrix[3] = {vtxMC[2], particle->Pt(), particle->Eta()};
 844          fGenTrackEventMatrix->Fill(vTrackEventMatrix);
 845
 846        }
 847      }//loop over stack
 848
 849      //
 850      // track-level corrections (zv,pt,eta)
 851      //
 852      if(isEventOK && isEventTriggered)
 853      {
 854
 855        // fill MC and rec event control histograms
 856        if(fHistogramsOn) {
 857          Double_t vRecMCEventHist1[3] = {vtxESD->GetXv()-vtxMC[0],vtxESD->GetYv()-vtxMC[1],vtxESD->GetZv()-vtxMC[2]};
 858          fRecMCEventHist1->Fill(vRecMCEventHist1);//
 859
 860          Double_t vRecMCEventHist2[3] = {vtxESD->GetXv()-vtxMC[0],vtxESD->GetZv()-vtxMC[2],multMBTracks};
 861          fRecMCEventHist2->Fill(vRecMCEventHist2);
 862
 863        }//
 864
 865        //
 866        // MC histograms for track efficiency studies
 867        //
 868        for (Int_t iMc = 0; iMc < stack->GetNtrack(); ++iMc)
 869        {
 870          TParticle* particle = stack->Particle(iMc);
 871          if (!particle)
 872          continue;
 873
 874          Double_t vTrackMatrix[3] = {vtxMC[2],particle->Pt(),particle->Eta()};
 875
 876          // only charged particles
 877          if(!particle->GetPDG()) continue;
 878          Double_t charge = particle->GetPDG()->Charge()/3.;
 879          if (TMath::Abs(charge) < 0.001)
 880          continue;
 881
 882          // only postive charged
 883          if(GetParticleMode() == AlidNdPtHelper::kPlus && charge < 0.)
 884          continue;
 885
 886          // only negative charged
 887          if(GetParticleMode() == AlidNdPtHelper::kMinus && charge > 0.)
 888          continue;
 889
 890          // physical primary
 891          Bool_t prim = stack->IsPhysicalPrimary(iMc);
 892
 893          // check accepted
 894          if(accCuts->AcceptTrack(particle))
 895          {
 896
 897            if( AlidNdPtHelper::IsPrimaryParticle(stack, iMc, GetParticleMode()) )
 898              fGenPrimTrackMatrix->Fill(vTrackMatrix);
 899
 900            // fill control histograms
 901            if(fHistogramsOn)
 902              FillHistograms(stack,iMc,AlidNdPtHelper::kAccTracks);
 903
 904            // check multiple found tracks
 905            Int_t multCount = 0;
 906            for(Int_t iRec=0; iRec<multRec; ++iRec)
 907            {
 908              if(iMc == labelsRec[iRec])
 909              {
 910                multCount++;
 911                if(multCount>1)
 912                {
 913                  fRecMultTrackMatrix->Fill(vTrackMatrix);
 914
 915                  // fill control histogram
 916                  if(fHistogramsOn) {
 917                    Int_t pid = AlidNdPtHelper::ConvertPdgToPid(particle);
 918                    Double_t vMCMultRecTrackHist1[3] = {particle->Pt(), particle->Eta(), pid};
 919                    fMCMultRecTrackHist1->Fill(vMCMultRecTrackHist1);
 920                  }
 921                }
 922              }
 923            }
 924
 925            // check reconstructed
 926            for(Int_t iRec=0; iRec<multRec; ++iRec)
 927            {
 928              if(iMc == labelsRec[iRec])
 929              {
 930                fRecTrackMatrix->Fill(vTrackMatrix);
 931
 932                if( AlidNdPtHelper::IsPrimaryParticle(stack, iMc, GetParticleMode()) ) {
 933                  fRecPrimTrackMatrix->Fill(vTrackMatrix);
 934                }
 935                if(!prim) fRecSecTrackMatrix->Fill(vTrackMatrix);
 936
 937                // fill control histograms
 938                if(fHistogramsOn)
 939                  FillHistograms(stack,iMc,AlidNdPtHelper::kRecTracks);
 940
 941                break;
 942              }//if(iMc == labelsRec[iRec])
 943            }//reco tracks
 944          }//accepted tracks
 945        }//stack loop
 946      }//is triggered
 947    } // end bUseMC
 948
 949   if(allChargedTracks) delete allChargedTracks; allChargedTracks = 0;
 950   if(labelsAll) delete [] labelsAll; labelsAll = 0;
 951   if(labelsAcc) delete [] labelsAcc; labelsAcc = 0;
 952   if(labelsRec) delete [] labelsRec; labelsRec = 0;
 953
 954   if(!evtCuts->IsRecVertexRequired() && vtxESD != NULL) delete vtxESD;
 955
 956 }
 957
 958 //_____________________________________________________________________________
 959 void AlidNdPtAnalysisPbPb::FillHistograms(TObjArray *const allChargedTracks,Int_t *const labelsAll,Int_t multAll,Int_t *const labelsAcc,Int_t multAcc,Int_t *const labelsRec,Int_t multRec) {
 960  // multiplicity  histograms
 961
 962
 963   if(!allChargedTracks) return;
 964   if(!labelsAll) return;
 965   if(!labelsAcc) return;
 966   if(!labelsRec) return;
 967
 968   Int_t entries = allChargedTracks->GetEntries();
 969   for(Int_t i=0; i<entries; ++i)
 970   {
 971      AliESDtrack *track = (AliESDtrack*)allChargedTracks->At(i);
 972      if(!track) continue;
 973      if(track->Charge() == 0) continue;
 974
 975      Int_t label = TMath::Abs(track->GetLabel());
 976      for(Int_t iAll=0; iAll<multAll; ++iAll) {
 977        if(label == labelsAll[iAll]) {
 978          Double_t v1[2] = {track->Pt(), multAll};
 979          fRecTrackMultHist1[AlidNdPtHelper::kAllTracks]->Fill(v1);
 980        }
 981      }
 982      for(Int_t iAcc=0; iAcc<multAcc; ++iAcc) {
 983        if(label == labelsAcc[iAcc]) {
 984          Double_t v2[2] = {track->Pt(), multAcc};
 985          fRecTrackMultHist1[AlidNdPtHelper::kAccTracks]->Fill(v2);
 986        }
 987      }
 988      for(Int_t iRec=0; iRec<multRec; ++iRec) {
 989        if(label == labelsRec[iRec]) {
 990          Double_t v3[2] = {track->Pt(), multRec};
 991          fRecTrackMultHist1[AlidNdPtHelper::kRecTracks]->Fill(v3);
 992        }//out
 993      }
 994   }
 995 }
 996
 997 //_____________________________________________________________________________
 998 void AlidNdPtAnalysisPbPb::FillHistograms(AliESDtrack *const esdTrack, AliStack *const stack, AlidNdPtHelper::TrackObject trackObj)
 999 {
1000
1001   //
1002   // Fill ESD track and MC histograms
1003   //
1004   if(!esdTrack) return;
1005
1006   Float_t q = esdTrack->Charge();
1007   if(TMath::Abs(q) < 0.001) return;
1008
1009   Float_t pt = esdTrack->Pt();
1010   Float_t eta = esdTrack->Eta();
1011   Float_t phi = esdTrack->Phi();
1012
1013   Float_t dca[2], bCov[3];
1014   esdTrack->GetImpactParameters(dca,bCov);
1015
1016   Int_t nClust = esdTrack->GetTPCclusters(0);
1017   Float_t chi2PerCluster = 0.;
1018   if(nClust>0.) chi2PerCluster = esdTrack->GetTPCchi2()/Float_t(nClust);
1019
1020
1021   // fill histograms
1022   Double_t values[3] = {pt,eta,phi};
1023   fRecTrackHist1[trackObj]->Fill(values);
1024
1025   //
1026   // Fill rec vs MC information
1027   //
1028   if(!stack) return;
1029
1030   Int_t label = TMath::Abs(esdTrack->GetLabel());
1031   //if(label == 0) return;
1032
1033   TParticle* particle = stack->Particle(label);
1034   if(!particle) return;
1035
1036   Int_t motherPdg = -1;
1037   TParticle* mother = 0;
1038
1039   //TParticle* prim_mother = AlidNdPtHelper::FindPrimaryMother(stack,label);
1040   Int_t motherLabel = particle->GetMother(0);
1041   if(motherLabel>0) mother = stack->Particle(motherLabel);
1042   if(mother) motherPdg = TMath::Abs(mother->GetPdgCode()); // take abs for visualisation only
1043   //Int_t mech = particle->GetUniqueID(); // production mechanism
1044
1045   if(!particle->GetPDG()) return;
1046   Double_t gq = particle->GetPDG()->Charge()/3.0; // Charge units |e|/3
1047   if(TMath::Abs(gq)<0.001) return;
1048   Float_t gpt = particle->Pt();
1049   Float_t geta = particle->Eta();
1050
1051   Double_t dpt=0;
1052   //printf("pt %f, gpt %f \n",pt,gpt);
1053   if(gpt) dpt = (pt-gpt)/gpt;
1054   Double_t deta = (eta-geta);
1055
1056   // fill histograms
1057   if(trackObj == AlidNdPtHelper::kRecTracks)  //RecTracks???
1058   {
1059     Double_t vTrackPtCorrelationMatrix[3]={pt,gpt,geta};
1060     fTrackPtCorrelationMatrix->Fill(vTrackPtCorrelationMatrix);
1061
1062     Double_t vRecMCTrackHist1[4]={gpt,geta,dpt,deta};
1063     fRecMCTrackHist1->Fill(vRecMCTrackHist1);
1064   }
1065 }
1066
1067 //_____________________________________________________________________________
1068 void AlidNdPtAnalysisPbPb::FillHistograms(AliStack *const stack, Int_t label, AlidNdPtHelper::TrackObject trackObj)
1069 {
1070
1071   // Fill MC histograms
1072   if(!stack) return;
1073
1074   TParticle* particle = stack->Particle(label);
1075   if(!particle) return;
1076
1077   Int_t motherPdg = -1;
1078   TParticle* mother = 0;
1079
1080   //TParticle* prim_mother = AlidNdPtHelper::FindPrimaryMother(stack,label);
1081   Int_t motherLabel = particle->GetMother(0);
1082   if(motherLabel>0) mother = stack->Particle(motherLabel);
1083   if(mother) motherPdg = TMath::Abs(mother->GetPdgCode()); // take abs for visualisation only
1084   Int_t mech = particle->GetUniqueID(); // production mechanism
1085
1086   if(!particle->GetPDG()) return;
1087   Double_t gq = particle->GetPDG()->Charge()/3.0; // Charge units |e|/3
1088   if(TMath::Abs(gq) < 0.001) return;
1089
1090   Float_t gpt = particle->Pt();
1091   //Float_t qgpt = particle->Pt() * gq;
1092   Float_t geta = particle->Eta();
1093   Float_t gphi = particle->Phi();
1094   //Float_t gpz = particle->Pz();
1095
1096   Bool_t prim = stack->IsPhysicalPrimary(label);
1097   //Float_t vx = particle->Vx(); Float_t vy = particle->Vy(); Float_t vz = particle->Vz();
1098
1099   Int_t pid = AlidNdPtHelper::ConvertPdgToPid(particle);
1100
1101   //if(prim&&pid==5) printf("pdgcode %d, production mech %d \n",particle->GetPdgCode(),mech);
1102   //if(!prim) printf("motherPdg %d, particle %d, production mech %d\n",motherPdg, particle->GetPdgCode(),mech);
1103
1104   //
1105   // fill histogram
1106   //
1107   Double_t vMCTrackHist1[3] = {gpt,geta,gphi};
1108   fMCTrackHist1[trackObj]->Fill(vMCTrackHist1);
1109
1110   Double_t vMCPrimTrackHist1[5] = {gpt,geta,pid,mech,motherPdg};
1111   Double_t vMCPrimTrackHist2[5] = {TMath::Abs(particle->GetPdgCode()),mech,motherPdg};
1112
1113   //if(prim && AliPWG0Helper::IsPrimaryCharged(particle, label)) fMCPrimTrackHist1[trackObj]->Fill(vMCPrimTrackHist1);
1114
1115   if(prim) {
1116     fMCPrimTrackHist1[trackObj]->Fill(vMCPrimTrackHist1);
1117     if(pid == 5) fMCPrimTrackHist2[trackObj]->Fill(vMCPrimTrackHist2);
1118   }
1119   else {
1120     fMCSecTrackHist1[trackObj]->Fill(vMCPrimTrackHist1);
1121   }
1122
1123 }
1124
1125 //_____________________________________________________________________________
1126 Long64_t AlidNdPtAnalysisPbPb::Merge(TCollection* const list)
1127 {
1128   // Merge list of objects (needed by PROOF)
1129
1130   if (!list)
1131   return 0;
1132
1133   if (list->IsEmpty())
1134   return 1;
1135
1136   TIterator* iter = list->MakeIterator();
1137   TObject* obj = 0;
1138
1139   //
1140   TList *collPhysSelection = new TList;
1141
1142   // collection of generated histograms
1143
1144   Int_t count=0;
1145   while((obj = iter->Next()) != 0) {
1146     AlidNdPtAnalysisPbPb* entry = dynamic_cast<AlidNdPtAnalysisPbPb*>(obj);
1147     if (entry == 0) continue;
1148
1149     // physics selection
1150     //printf("entry->GetPhysicsTriggerSelection() %p \n", entry->GetPhysicsTriggerSelection());
1151     collPhysSelection->Add(entry->GetPhysicsTriggerSelection());
1152
1153     //
1154     fTrackPtCorrelationMatrix->Add(entry->fTrackPtCorrelationMatrix);
1155
1156     //
1157     fGenEventMatrix->Add(entry->fGenEventMatrix);
1158
1159     fTriggerEventMatrix->Add(entry->fTriggerEventMatrix);
1160
1161     fRecEventMatrix->Add(entry->fRecEventMatrix);
1162     //
1163     fGenTrackEventMatrix->Add(entry->fGenTrackEventMatrix);
1164
1165     fTriggerTrackEventMatrix->Add(entry->fTriggerTrackEventMatrix);
1166
1167     fRecTrackEventMatrix->Add(entry->fRecTrackEventMatrix);
1168
1169     //
1170     fGenTrackMatrix->Add(entry->fGenTrackMatrix);
1171     fGenPrimTrackMatrix->Add(entry->fGenPrimTrackMatrix);
1172     fRecPrimTrackMatrix->Add(entry->fRecPrimTrackMatrix);
1173     //
1174     fRecTrackMatrix->Add(entry->fRecTrackMatrix);
1175     fRecSecTrackMatrix->Add(entry->fRecSecTrackMatrix);
1176     //
1177     fRecMultTrackMatrix->Add(entry->fRecMultTrackMatrix);
1178
1179     //
1180     // control analysis histograms
1181     //
1182     fMCEventHist1->Add(entry->fMCEventHist1);
1183     fRecEventHist1->Add(entry->fRecEventHist1);
1184     fRecEventHist2->Add(entry->fRecEventHist2);
1185     fRecMCEventHist1->Add(entry->fRecMCEventHist1);
1186     fRecMCEventHist2->Add(entry->fRecMCEventHist2);
1187
1188
1189     for(Int_t i=0; i<AlidNdPtHelper::kCutSteps; i++) {
1190       fMCTrackHist1[i]->Add(entry->fMCTrackHist1[i]);
1191
1192       fMCPrimTrackHist1[i]->Add(entry->fMCPrimTrackHist1[i]);
1193       fMCPrimTrackHist2[i]->Add(entry->fMCPrimTrackHist2[i]);
1194       fMCSecTrackHist1[i]->Add(entry->fMCSecTrackHist1[i]);
1195
1196       fRecTrackHist1[i]->Add(entry->fRecTrackHist1[i]);
1197       fRecTrackMultHist1[i]->Add(entry->fRecTrackMultHist1[i]);
1198     }
1199     fRecMCTrackHist1->Add(entry->fRecMCTrackHist1);
1200     fMCMultRecTrackHist1->Add(entry->fMCMultRecTrackHist1);
1201     fRecTrackHist2->Add(entry->fRecTrackHist2);
1202
1203   count++;
1204   }
1205
1206   AliPhysicsSelection *trigSelection = GetPhysicsTriggerSelection();
1207   trigSelection->Merge(collPhysSelection);
1208   if(collPhysSelection) delete collPhysSelection;
1209
1210 return count;
1211 }
1212
1213
1214
1215 //_____________________________________________________________________________
1216 void AlidNdPtAnalysisPbPb::Analyse()
1217 {
1218   // Analyse histograms
1219   //
1220   TH1::AddDirectory(kFALSE);
1221   TH1 *h=0, *h1=0, *h2=0, *h2c = 0;
1222   THnSparse *hs=0;
1223   TH2 *h2D=0;
1224
1225   char name[256];
1226   TObjArray *aFolderObj = new TObjArray;
1227
1228   //
1229   // LHC backgraund in all and 0-bins
1230   //
1231   AliPhysicsSelection *trigSel = GetPhysicsTriggerSelection();
1232   trigSel->SaveHistograms("physics_selection");
1233
1234   //
1235   // Reconstructed event vertex
1236   //
1237   h = fRecEventHist1->Projection(0);
1238   h->SetName("Xv");
1239   aFolderObj->Add(h);
1240
1241   h = fRecEventHist1->Projection(1);
1242   h->SetName("Yv");
1243   aFolderObj->Add(h);
1244
1245   h = fRecEventHist1->Projection(2);
1246   h->SetName("Zv");
1247   aFolderObj->Add(h);
1248
1249   //
1250   // multiplicity
1251   //
1252   h = fRecEventHist2->Projection(1);
1253   h->SetName("multMB");
1254   aFolderObj->Add(h);
1255
1256   h = fRecEventHist2->Projection(2);
1257   h->SetName("multiplicity");
1258   aFolderObj->Add(h);
1259
1260   h2D = fRecEventHist2->Projection(0,1);
1261   h2D->SetName("Zv_vs_multiplicity_MB");
1262   aFolderObj->Add(h2D);
1263
1264   //
1265   // reconstructed pt histograms
1266   //
1267   h = fRecTrackHist1[0]->Projection(0);
1268   h->Scale(1.,"width");
1269   h->SetName("pt_all_ch");
1270   aFolderObj->Add(h);
1271
1272   h = fRecTrackHist1[1]->Projection(0);
1273   h->Scale(1.,"width");
1274   h->SetName("pt_acc");
1275   aFolderObj->Add(h);
1276
1277   h = fRecTrackHist1[2]->Projection(0);
1278   h->Scale(1.,"width");
1279   h->SetName("pt_rec");
1280   aFolderObj->Add(h);
1281
1282   //
1283   // reconstructed eta histograms
1284   //
1285   h = fRecTrackHist1[0]->Projection(1);
1286   h->SetName("eta_all_ch");
1287   aFolderObj->Add(h);
1288
1289   h = fRecTrackHist1[1]->Projection(1);
1290   h->SetName("eta_acc");
1291   aFolderObj->Add(h);
1292
1293   h = fRecTrackHist1[2]->Projection(1);
1294   h->SetName("eta_rec");
1295   aFolderObj->Add(h);
1296
1297   //
1298   // reconstructed phi histograms
1299   //
1300   h = fRecTrackHist1[0]->Projection(2);
1301   h->SetName("phi_all_ch");
1302   aFolderObj->Add(h);
1303
1304   h = fRecTrackHist1[1]->Projection(2);
1305   h->SetName("phi_acc");
1306   aFolderObj->Add(h);
1307
1308   h = fRecTrackHist1[2]->Projection(2);
1309   h->SetName("phi_rec");
1310   aFolderObj->Add(h);
1311
1312   //
1313   // reconstructed eta:pt histograms
1314   //
1315   h2D = fRecTrackHist1[0]->Projection(1,0);
1316   h2D->SetName("pt_eta_all_ch");
1317   aFolderObj->Add(h2D);
1318
1319   h2D = fRecTrackHist1[1]->Projection(1,0);
1320   h2D->SetName("pt_eta_acc");
1321   aFolderObj->Add(h2D);
1322
1323   h2D = fRecTrackHist1[2]->Projection(1,0);
1324   h2D->SetName("pt_eta_rec");
1325   aFolderObj->Add(h2D);
1326
1327   //
1328   // reconstructed phi:pt histograms
1329   //
1330   h2D = fRecTrackHist1[0]->Projection(2,0);
1331   h2D->SetName("pt_phi_all_ch");
1332   aFolderObj->Add(h2D);
1333
1334   h2D = fRecTrackHist1[1]->Projection(2,0);
1335   h2D->SetName("pt_phi_acc");
1336   aFolderObj->Add(h2D);
1337
1338   h2D = fRecTrackHist1[2]->Projection(2,0);
1339   h2D->SetName("pt_phi_rec");
1340   aFolderObj->Add(h2D);
1341
1342   //
1343   // reconstructed phi:eta histograms
1344   //
1345   h2D = fRecTrackHist1[0]->Projection(2,1);
1346   h2D->SetName("eta_phi_all_ch");
1347   aFolderObj->Add(h2D);
1348
1349   h2D = fRecTrackHist1[1]->Projection(2,1);
1350   h2D->SetName("eta_phi_acc");
1351   aFolderObj->Add(h2D);
1352
1353   h2D = fRecTrackHist1[2]->Projection(2,1);
1354   h2D->SetName("eta_phi_rec");
1355   aFolderObj->Add(h2D);
1356
1357   //
1358   // reconstructed nClust, chi2 vs pt, eta, phi
1359   //
1360   if(fHistogramsOn) {
1361
1362     h2D = fRecTrackHist2->Projection(0,1);
1363     h2D->SetName("nClust_chi2_rec");
1364     aFolderObj->Add(h2D);
1365
1366     h2D = fRecTrackHist2->Projection(0,2);
1367     h2D->SetName("nClust_pt_rec");
1368     aFolderObj->Add(h2D);
1369
1370     h2D = fRecTrackHist2->Projection(0,3);
1371     h2D->SetName("nClust_eta_rec");
1372     aFolderObj->Add(h2D);
1373
1374     h2D = fRecTrackHist2->Projection(0,4);
1375     h2D->SetName("nClust_phi_rec");
1376     aFolderObj->Add(h2D);
1377
1378     h2D = fRecTrackHist2->Projection(1,2);
1379     h2D->SetName("chi2_pt_rec");
1380     aFolderObj->Add(h2D);
1381
1382     h2D = fRecTrackHist2->Projection(1,3);
1383     h2D->SetName("chi2_eta_rec");
1384     aFolderObj->Add(h2D);
1385
1386     h2D = fRecTrackHist2->Projection(1,4);
1387     h2D->SetName("chi2_phi_rec");
1388     aFolderObj->Add(h2D);
1389
1390   }
1391
1392   //
1393   // calculate corrections for empty events
1394   // with multMB==0
1395   //
1396
1397   //
1398   // normalised zv to generate zv for triggered events
1399   //
1400   h = fRecEventHist2->Projection(0);
1401   if( h->Integral() ) h->Scale(1./h->Integral());
1402   h->SetName("zv_distribution_norm");
1403   aFolderObj->Add(h);
1404
1405   //
1406   // MC available
1407   //
1408   if(IsUseMCInfo()) {
1409
1410   //
1411   // Event vertex resolution
1412   //
1413   h2D = fRecMCEventHist2->Projection(0,2);
1414   h2D->SetName("DeltaXv_vs_mult");
1415   aFolderObj->Add(h2D);
1416
1417   h2D = fRecMCEventHist2->Projection(1,2);
1418   h2D->SetName("DeltaZv_vs_mult");
1419   aFolderObj->Add(h2D);
1420
1421   //
1422   // normalised zv to get trigger/trigger+vertex event differences
1423   // F(zv) = E_trig(zv,0)/Int(E_trig(zv,0) / Sum(E_trigvtx(zv,n))/Sum(Int(E_trigvtx(zv,n))dzv)
1424   //
1425   fTriggerEventMatrix->GetAxis(1)->SetRangeUser(0.,0.);
1426   h = fTriggerEventMatrix->Projection(0);
1427   h2D = fTriggerEventMatrix->Projection(0,1);
1428   if(h2D->Integral()) h->Scale(1./h2D->Integral());
1429
1430   h1 = fRecEventMatrix->Projection(0);
1431   h2D = fRecEventMatrix->Projection(0,1);
1432   if(h2D->Integral()) h1->Scale(1./h2D->Integral());
1433
1434   h->Divide(h1);
1435   h->SetName("zv_empty_events_norm");
1436   aFolderObj->Add(h);
1437
1438   fTriggerEventMatrix->GetAxis(1)->SetRange(1,fTriggerEventMatrix->GetAxis(1)->GetNbins());
1439
1440   //
1441   // rec. vs true track pt correlation matrix
1442   //
1443   hs = (THnSparse*)fTrackPtCorrelationMatrix->Clone("track_pt_correlation_matrix");
1444   aFolderObj->Add(hs);
1445
1446   //
1447   // trigger efficiency for INEL
1448   //
1449   h = AlidNdPtHelper::GenerateCorrMatrix(fTriggerEventMatrix->Projection(0),fGenEventMatrix->Projection(0),"zv_trig_INEL_eff_matrix");
1450   aFolderObj->Add(h);
1451
1452
1453   //
1454   // trigger bias correction (MB to INEL)
1455   //
1456   hs = AlidNdPtHelper::GenerateCorrMatrix(fGenEventMatrix,fTriggerEventMatrix,"zv_mult_trig_MBtoInel_corr_matrix");
1457   aFolderObj->Add(hs);
1458
1459   h = AlidNdPtHelper::GenerateCorrMatrix(fGenEventMatrix->Projection(0),fTriggerEventMatrix->Projection(0),"zv_trig_MBtoInel_corr_matrix");
1460   aFolderObj->Add(h);
1461
1462   h2D = AlidNdPtHelper::GenerateCorrMatrix(fGenEventMatrix->Projection(0,1),fTriggerEventMatrix->Projection(0,1),"zv_mult_trig_MBtoInel_corr_matrix_2D");
1463   aFolderObj->Add(h2D);
1464
1465
1466   h = AlidNdPtHelper::GenerateCorrMatrix(fGenEventMatrix->Projection(1),fTriggerEventMatrix->Projection(1),"mult_trig_MBtoInel_corr_matrix");
1467   aFolderObj->Add(h);
1468
1469
1470   //
1471   // event vertex reconstruction correction (MB)
1472   //
1473   hs = AlidNdPtHelper::GenerateCorrMatrix(fTriggerEventMatrix,fRecEventMatrix,"zv_mult_event_corr_matrix");
1474   aFolderObj->Add(hs);
1475
1476   h2D = AlidNdPtHelper::GenerateCorrMatrix(fTriggerEventMatrix->Projection(0,1),fRecEventMatrix->Projection(0,1),"zv_mult_event_corr_matrix_2D");
1477   aFolderObj->Add(h2D);
1478
1479
1480   h = AlidNdPtHelper::GenerateCorrMatrix(fTriggerEventMatrix->Projection(1),fRecEventMatrix->Projection(1),"mult_event_corr_matrix");
1481   aFolderObj->Add(h);
1482
1483
1484   h = AlidNdPtHelper::GenerateCorrMatrix(fTriggerEventMatrix->Projection(0),fRecEventMatrix->Projection(0),"zv_event_corr_matrix");
1485   aFolderObj->Add(h);
1486
1487
1488
1489   //
1490   // track-event trigger bias correction (MB to INEL)
1491   //
1492   hs = AlidNdPtHelper::GenerateCorrMatrix(fGenTrackEventMatrix,fTriggerTrackEventMatrix,"zv_pt_eta_track_trig_MBtoInel_corr_matrix");
1493   aFolderObj->Add(hs);
1494
1495   h2D = AlidNdPtHelper::GenerateCorrMatrix(fGenTrackEventMatrix->Projection(1,2),fTriggerTrackEventMatrix->Projection(1,2),"eta_pt_track_trig_MBtoInel_corr_matrix");
1496   aFolderObj->Add(h2D);
1497
1498   h2D = AlidNdPtHelper::GenerateCorrMatrix(fGenTrackEventMatrix->Projection(1,0),fTriggerTrackEventMatrix->Projection(1,0),"pt_zv_track_trig_MBtoInel_corr_matrix");
1499   aFolderObj->Add(h2D);
1500
1501   h2D = AlidNdPtHelper::GenerateCorrMatrix(fGenTrackEventMatrix->Projection(2,0),fTriggerTrackEventMatrix->Projection(2,0),"zv_eta_track_trig_MBtoInel_corr_matrix");
1502   aFolderObj->Add(h2D);
1503
1504   // efficiency
1505
1506   h = AlidNdPtHelper::GenerateCorrMatrix(fTriggerTrackEventMatrix->Projection(1),fGenTrackEventMatrix->Projection(1),"pt_track_trig_MBtoInel_eff_matrix");
1507   aFolderObj->Add(h);
1508
1509
1510   //
1511   // track-event vertex reconstruction correction (MB)
1512   //
1513   hs = AlidNdPtHelper::GenerateCorrMatrix(fTriggerTrackEventMatrix,fRecTrackEventMatrix,"zv_pt_eta_track_event_corr_matrix");
1514   aFolderObj->Add(hs);
1515
1516   h2D = AlidNdPtHelper::GenerateCorrMatrix(fTriggerTrackEventMatrix->Projection(1,2),fRecTrackEventMatrix->Projection(1,2),"eta_pt_track_event_corr_matrix");
1517   aFolderObj->Add(h2D);
1518
1519   h2D = AlidNdPtHelper::GenerateCorrMatrix(fTriggerTrackEventMatrix->Projection(1,0),fRecTrackEventMatrix->Projection(1,0),"pt_zv_track_event_corr_matrix");
1520   aFolderObj->Add(h2D);
1521
1522   h2D = AlidNdPtHelper::GenerateCorrMatrix(fTriggerTrackEventMatrix->Projection(2,0),fRecTrackEventMatrix->Projection(2,0),"zv_eta_track_event_corr_matrix");
1523   aFolderObj->Add(h2D);
1524
1525   // efficiency
1526
1527   h = AlidNdPtHelper::GenerateCorrMatrix(fRecTrackEventMatrix->Projection(1),fTriggerTrackEventMatrix->Projection(1),"pt_track_event_eff_matrix");
1528   aFolderObj->Add(h);
1529
1530
1531   //
1532   // track rec. efficiency correction
1533   //
1534   hs = AlidNdPtHelper::GenerateCorrMatrix(fGenPrimTrackMatrix,fRecPrimTrackMatrix,"zv_pt_eta_track_corr_matrix");
1535   aFolderObj->Add(hs);
1536
1537   h2D = AlidNdPtHelper::GenerateCorrMatrix(fGenPrimTrackMatrix->Projection(1,2),fRecPrimTrackMatrix->Projection(1,2),"eta_pt_track_corr_matrix");
1538   aFolderObj->Add(h2D);
1539
1540   h2D = AlidNdPtHelper::GenerateCorrMatrix(fGenPrimTrackMatrix->Projection(1,0),fRecPrimTrackMatrix->Projection(1,0),"pt_zv_track_corr_matrix");
1541   aFolderObj->Add(h2D);
1542
1543   h2D = AlidNdPtHelper::GenerateCorrMatrix(fGenPrimTrackMatrix->Projection(2,0),fRecPrimTrackMatrix->Projection(2,0),"zv_eta_track_corr_matrix");
1544   aFolderObj->Add(h2D);
1545
1546
1547   h = AlidNdPtHelper::GenerateCorrMatrix(fGenPrimTrackMatrix->Projection(0),fRecPrimTrackMatrix->Projection(0),"zv_track_corr_matrix");
1548   aFolderObj->Add(h);
1549
1550   h = AlidNdPtHelper::GenerateCorrMatrix(fGenPrimTrackMatrix->Projection(1),fRecPrimTrackMatrix->Projection(1),"pt_track_corr_matrix");
1551   aFolderObj->Add(h);
1552
1553   // efficiency
1554
1555   h = AlidNdPtHelper::GenerateCorrMatrix(fRecPrimTrackMatrix->Projection(1), fGenPrimTrackMatrix->Projection(1),"pt_track_eff_matrix");
1556   aFolderObj->Add(h);
1557
1558   h = AlidNdPtHelper::GenerateCorrMatrix(fGenPrimTrackMatrix->Projection(2),fRecPrimTrackMatrix->Projection(2),"eta_track_corr_matrix");
1559   aFolderObj->Add(h);
1560
1561   //
1562   // secondary track contamination correction
1563   //
1564   //hs = AlidNdPtHelper::GenerateContCorrMatrix(fRecSecTrackMatrix,fRecTrackMatrix,"zv_pt_eta_track_cont_matrix");
1565   hs = AlidNdPtHelper::GenerateCorrMatrix(fRecSecTrackMatrix,fRecTrackMatrix,"zv_pt_eta_track_cont_matrix");
1566   aFolderObj->Add(hs);
1567
1568   h2D = AlidNdPtHelper::GenerateCorrMatrix(fRecSecTrackMatrix->Projection(1,2),fRecTrackMatrix->Projection(1,2),"eta_pt_track_cont_matrix");
1569   aFolderObj->Add(h2D);
1570
1571   h2D = AlidNdPtHelper::GenerateCorrMatrix(fRecSecTrackMatrix->Projection(1,0),fRecTrackMatrix->Projection(1,0),"pt_zv_track_cont_matrix");
1572   aFolderObj->Add(h2D);
1573
1574   h2D = AlidNdPtHelper::GenerateCorrMatrix(fRecSecTrackMatrix->Projection(2,0),fRecTrackMatrix->Projection(2,0),"zv_eta_track_cont_matrix");
1575   aFolderObj->Add(h2D);
1576
1577   h = AlidNdPtHelper::GenerateCorrMatrix(fRecSecTrackMatrix->Projection(0),fRecTrackMatrix->Projection(0),"zv_track_cont_matrix");
1578   aFolderObj->Add(h);
1579
1580
1581   h = AlidNdPtHelper::GenerateCorrMatrix(fRecSecTrackMatrix->Projection(1),fRecTrackMatrix->Projection(1),"pt_track_cont_matrix");
1582   aFolderObj->Add(h);
1583
1584   h = AlidNdPtHelper::GenerateCorrMatrix(fRecSecTrackMatrix->Projection(2),fRecTrackMatrix->Projection(2),"eta_track_cont_matrix");
1585   aFolderObj->Add(h);
1586
1587   //
1588   // multiple track reconstruction correction
1589   //
1590   //hs = AlidNdPtHelper::GenerateContCorrMatrix(fRecMultTrackMatrix,fRecTrackMatrix,"zv_pt_eta_mult_track_cont_matrix");
1591   hs = AlidNdPtHelper::GenerateCorrMatrix(fRecMultTrackMatrix,fRecTrackMatrix,"zv_pt_eta_mult_track_cont_matrix");
1592   aFolderObj->Add(hs);
1593
1594   h2D = AlidNdPtHelper::GenerateCorrMatrix(fRecMultTrackMatrix->Projection(1,2),fRecTrackMatrix->Projection(1,2),"eta_pt_mult_track_cont_matrix");
1595   aFolderObj->Add(h2D);
1596
1597   h2D = AlidNdPtHelper::GenerateCorrMatrix(fRecMultTrackMatrix->Projection(1,0),fRecTrackMatrix->Projection(1,0),"pt_zv_mult_track_cont_matrix");
1598   aFolderObj->Add(h2D);
1599
1600   h2D = AlidNdPtHelper::GenerateCorrMatrix(fRecMultTrackMatrix->Projection(2,0),fRecTrackMatrix->Projection(2,0),"zv_eta_mult_track_cont_matrix");
1601   aFolderObj->Add(h2D);
1602
1603   h = AlidNdPtHelper::GenerateCorrMatrix(fRecMultTrackMatrix->Projection(0),fRecTrackMatrix->Projection(0),"zv_mult_track_cont_matrix");
1604   aFolderObj->Add(h);
1605
1606   h = AlidNdPtHelper::GenerateCorrMatrix(fRecMultTrackMatrix->Projection(1),fRecTrackMatrix->Projection(1),"pt_mult_track_cont_matrix");
1607   aFolderObj->Add(h);
1608
1609   h = AlidNdPtHelper::GenerateCorrMatrix(fRecMultTrackMatrix->Projection(2),fRecTrackMatrix->Projection(2),"eta_mult_track_cont_matrix");
1610   aFolderObj->Add(h);
1611
1612   //
1613   // Control histograms
1614   //
1615
1616   if(fHistogramsOn) {
1617
1618   // Efficiency electrons, muons, pions, kaons, protons, all
1619   fMCPrimTrackHist1[1]->GetAxis(2)->SetRange(1,1);
1620   fMCPrimTrackHist1[2]->GetAxis(2)->SetRange(1,1);
1621   h1 = fMCPrimTrackHist1[1]->Projection(0);
1622   h2 = fMCPrimTrackHist1[2]->Projection(0);
1623   h2c = (TH1D *)h2->Clone();
1624   h2c->Divide(h1);
1625   h2c->SetName("eff_pt_electrons");
1626   aFolderObj->Add(h2c);
1627
1628   fMCPrimTrackHist1[1]->GetAxis(2)->SetRange(2,2);
1629   fMCPrimTrackHist1[2]->GetAxis(2)->SetRange(2,2);
1630   h1 = fMCPrimTrackHist1[1]->Projection(0);
1631   h2 = fMCPrimTrackHist1[2]->Projection(0);
1632   h2c = (TH1D *)h2->Clone();
1633   h2c->Divide(h1);
1634   h2c->SetName("eff_pt_muons");
1635   aFolderObj->Add(h2c);
1636
1637   fMCPrimTrackHist1[1]->GetAxis(2)->SetRange(3,3);
1638   fMCPrimTrackHist1[2]->GetAxis(2)->SetRange(3,3);
1639   h1 = fMCPrimTrackHist1[1]->Projection(0);
1640   h2 = fMCPrimTrackHist1[2]->Projection(0);
1641   h2c = (TH1D *)h2->Clone();
1642   h2c->Divide(h1);
1643   h2c->SetName("eff_pt_pions");
1644   aFolderObj->Add(h2c);
1645
1646   fMCPrimTrackHist1[1]->GetAxis(2)->SetRange(4,4);
1647   fMCPrimTrackHist1[2]->GetAxis(2)->SetRange(4,4);
1648   h1 = fMCPrimTrackHist1[1]->Projection(0);
1649   h2 = fMCPrimTrackHist1[2]->Projection(0);
1650   h2c = (TH1D *)h2->Clone();
1651   h2c->Divide(h1);
1652   h2c->SetName("eff_pt_kaons");
1653   aFolderObj->Add(h2c);
1654
1655   fMCPrimTrackHist1[1]->GetAxis(2)->SetRange(5,5);
1656   fMCPrimTrackHist1[2]->GetAxis(2)->SetRange(5,5);
1657   h1 = fMCPrimTrackHist1[1]->Projection(0);
1658   h2 = fMCPrimTrackHist1[2]->Projection(0);
1659   h2c = (TH1D *)h2->Clone();
1660   h2c->Divide(h1);
1661   h2c->SetName("eff_pt_protons");
1662   aFolderObj->Add(h2c);
1663
1664   fMCPrimTrackHist1[1]->GetAxis(2)->SetRange(1,5);
1665   fMCPrimTrackHist1[2]->GetAxis(2)->SetRange(1,5);
1666   h1 = fMCPrimTrackHist1[1]->Projection(0);
1667   h2 = fMCPrimTrackHist1[2]->Projection(0);
1668   h2c = (TH1D *)h2->Clone();
1669   h2c->Divide(h1);
1670   h2c->SetName("eff_pt_selected");
1671   aFolderObj->Add(h2c);
1672
1673   fMCPrimTrackHist1[1]->GetAxis(2)->SetRange(1,6);
1674   fMCPrimTrackHist1[2]->GetAxis(2)->SetRange(1,6);
1675   h1 = fMCPrimTrackHist1[1]->Projection(0);
1676   h2 = fMCPrimTrackHist1[2]->Projection(0);
1677   h2c = (TH1D *)h2->Clone();
1678   h2c->Divide(h1);
1679   h2c->SetName("eff_pt_all");
1680   aFolderObj->Add(h2c);
1681
1682   fMCPrimTrackHist1[1]->GetAxis(1)->SetRange(1,fMCPrimTrackHist1[1]->GetAxis(1)->GetNbins());
1683   fMCPrimTrackHist1[2]->GetAxis(1)->SetRange(1,fMCPrimTrackHist1[2]->GetAxis(1)->GetNbins());
1684
1685   //  pt spetra
1686   // - rec, primaries, secondaries
1687   // - primaries (pid)
1688   // - secondaries (pid)
1689   // - secondaries (mech)
1690   // - secondaries (mother)
1691   //
1692
1693   TH1D *mcPtAccall = fMCTrackHist1[1]->Projection(0);
1694   mcPtAccall->SetName("mc_pt_acc_all");
1695   aFolderObj->Add(mcPtAccall);
1696
1697   TH1D *mcPtAccprim = fMCPrimTrackHist1[1]->Projection(0);
1698   mcPtAccprim->SetName("mc_pt_acc_prim");
1699   aFolderObj->Add(mcPtAccprim);
1700
1701   TH1D *mcPtRecall = fMCTrackHist1[2]->Projection(0);
1702   mcPtRecall->SetName("mc_pt_rec_all");
1703   aFolderObj->Add(mcPtRecall);
1704
1705   TH1D *mcPtRecprim = fMCPrimTrackHist1[2]->Projection(0);
1706   mcPtRecprim->SetName("mc_pt_rec_prim");
1707   aFolderObj->Add(mcPtRecprim);
1708
1709   TH1D *mcPtRecsec = fMCSecTrackHist1[2]->Projection(0);
1710   mcPtRecsec->SetName("mc_pt_rec_sec");
1711   aFolderObj->Add(mcPtRecsec);
1712
1713   for(Int_t i = 0; i<6; i++)
1714   {
1715     sprintf(name,"mc_pt_rec_prim_pid_%d",i);
1716     fMCPrimTrackHist1[2]->GetAxis(2)->SetRange(i+1,i+1);
1717     h = fMCPrimTrackHist1[2]->Projection(0);
1718     h->SetName(name);
1719     aFolderObj->Add(h);
1720
1721     sprintf(name,"mc_pt_rec_sec_pid_%d",i);
1722     fMCSecTrackHist1[2]->GetAxis(2)->SetRange(i+1,i+1);
1723     h = fMCSecTrackHist1[2]->Projection(0);
1724     h->SetName(name);
1725     aFolderObj->Add(h);
1726
1727     // production mechanisms for given pid
1728     fMCSecTrackHist1[2]->GetAxis(2)->SetRange(i+1,i+1);
1729
1730     for(Int_t j=0; j<20; j++) {
1731       if(j == 4) {
1732         // decay
1733
1734         sprintf(name,"mc_pt_rec_sec_pid_%d_decay",i);
1735         fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
1736         h = fMCSecTrackHist1[2]->Projection(0);
1737         h->SetName(name);
1738         aFolderObj->Add(h);
1739
1740         sprintf(name,"mc_eta_rec_sec_pid_%d_decay",i);
1741         fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
1742         h = fMCSecTrackHist1[2]->Projection(1);
1743         h->SetName(name);
1744         aFolderObj->Add(h);
1745
1746         sprintf(name,"mc_mother_rec_sec_pid_%d_decay",i);
1747         fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
1748         h = fMCSecTrackHist1[2]->Projection(4);
1749         h->SetName(name);
1750         aFolderObj->Add(h);
1751
1752       } else if (j == 5) {
1753        // conversion
1754
1755         sprintf(name,"mc_pt_rec_sec_pid_%d_conv",i);
1756         fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
1757         h = fMCSecTrackHist1[2]->Projection(0);
1758         h->SetName(name);
1759         aFolderObj->Add(h);
1760
1761         sprintf(name,"mc_eta_rec_sec_pid_%d_conv",i);
1762         fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
1763         h = fMCSecTrackHist1[2]->Projection(1);
1764         h->SetName(name);
1765         aFolderObj->Add(h);
1766
1767         sprintf(name,"mc_mother_rec_sec_pid_%d_conv",i);
1768         fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
1769         h = fMCSecTrackHist1[2]->Projection(4);
1770         h->SetName(name);
1771         aFolderObj->Add(h);
1772
1773      } else if (j == 13) {
1774        // mat
1775
1776         sprintf(name,"mc_pt_rec_sec_pid_%d_mat",i);
1777         fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
1778         h = fMCSecTrackHist1[2]->Projection(0);
1779         h->SetName(name);
1780         aFolderObj->Add(h);
1781
1782         sprintf(name,"mc_eta_rec_sec_pid_%d_mat",i);
1783         fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
1784         h = fMCSecTrackHist1[2]->Projection(1);
1785         h->SetName(name);
1786         aFolderObj->Add(h);
1787
1788         sprintf(name,"mc_eta_mother_rec_sec_pid_%d_mat",i);
1789         fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
1790         h = fMCSecTrackHist1[2]->Projection(4,1);
1791         h->SetName(name);
1792         aFolderObj->Add(h);
1793
1794         sprintf(name,"mc_mother_rec_sec_pid_%d_mat",i);
1795         fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
1796         h = fMCSecTrackHist1[2]->Projection(4);
1797         h->SetName(name);
1798         aFolderObj->Add(h);
1799
1800         sprintf(name,"mc_pt_mother_rec_sec_pid_%d_mat",i);
1801         fMCSecTrackHist1[2]->GetAxis(3)->SetRange(j+1,j+1);
1802         h = fMCSecTrackHist1[2]->Projection(4,0);
1803         h->SetName(name);
1804         aFolderObj->Add(h);
1805
1806      } else {
1807        continue;
1808      }
1809    }
1810
1811   }
1812   } // end fHistogramOn
1813
1814   //
1815   //  resolution histograms
1816   //  only for reconstructed tracks
1817   //
1818
1819   TH2F *h2F=0;
1820   TCanvas * c = new TCanvas("resol","resol");
1821   c->cd();
1822
1823   //
1824   fRecMCTrackHist1->GetAxis(1)->SetRangeUser(-0.8,0.79);
1825
1826   h2F = (TH2F*)fRecMCTrackHist1->Projection(2,0);
1827   h = AlidNdPtHelper::MakeResol(h2F,1,0,kTRUE,10);
1828   h->SetXTitle("p_{tmc} (GeV/c)");
1829   h->SetYTitle("(p_{t}-p_{tmc})/p_{tmc} resolution");
1830   h->Draw();
1831   h->SetName("pt_resolution_vs_mcpt");
1832   aFolderObj->Add(h);
1833
1834   h2F = (TH2F*)fRecMCTrackHist1->Projection(2,0);
1835   h = AlidNdPtHelper::MakeResol(h2F,1,1,kTRUE,10);
1836   h->SetXTitle("p_{tmc} (GeV/c)");
1837   h->SetYTitle("(p_{t}-p_{tmc})/p_{tmc} mean");
1838   h->Draw();
1839   h->SetName("dpt_mean_vs_mcpt");
1840   aFolderObj->Add(h);
1841
1842   //
1843   h2F = (TH2F*)fRecMCTrackHist1->Projection(3,0);
1844   h = AlidNdPtHelper::MakeResol(h2F,1,0,kTRUE,10);
1845   h->SetXTitle("p_{tmc} (GeV/c)");
1846   h->SetYTitle("(#eta-#eta_{mc}) resolution");
1847   h->Draw();
1848   h->SetName("eta_resolution_vs_mcpt");
1849   aFolderObj->Add(h);
1850
1851   h2F = (TH2F*)fRecMCTrackHist1->Projection(3,0);
1852   h = AlidNdPtHelper::MakeResol(h2F,1,1,kTRUE,10);
1853   h->SetXTitle("p_{tmc} (GeV/c)");
1854   h->SetYTitle("(#eta-mc#eta) mean");
1855   h->Draw();
1856   h->SetName("deta_mean_vs_mcpt");
1857   aFolderObj->Add(h);
1858
1859   //
1860   fRecMCTrackHist1->GetAxis(1)->SetRange(1,fRecMCTrackHist1->GetAxis(1)->GetNbins());
1861
1862   h2F = (TH2F*)fRecMCTrackHist1->Projection(2,1);
1863   h = AlidNdPtHelper::MakeResol(h2F,1,0,kTRUE,10);
1864   h->SetXTitle("#eta_{mc}");
1865   h->SetYTitle("(p_{t}-p_{tmc})/p_{tmc} resolution");
1866   h->Draw();
1867   h->SetName("pt_resolution_vs_mceta");
1868   aFolderObj->Add(h);
1869
1870   h2F = (TH2F*)fRecMCTrackHist1->Projection(2,1);
1871   h = AlidNdPtHelper::MakeResol(h2F,1,1,kTRUE,10);
1872   h->SetXTitle("#eta_{mc}");
1873   h->SetYTitle("(p_{t}-p_{tmc})/p_{tmc} mean");
1874   h->Draw();
1875   h->SetName("dpt_mean_vs_mceta");
1876   aFolderObj->Add(h);
1877
1878   //
1879   h2F = (TH2F*)fRecMCTrackHist1->Projection(3,1);
1880   h = AlidNdPtHelper::MakeResol(h2F,1,0,kTRUE,10);
1881   h->SetXTitle("#eta_{mc}");
1882   h->SetYTitle("(#eta-#eta_{mc}) resolution");
1883   h->Draw();
1884   h->SetName("eta_resolution_vs_mceta");
1885   aFolderObj->Add(h);
1886
1887   h2F = (TH2F*)fRecMCTrackHist1->Projection(3,1);
1888   h = AlidNdPtHelper::MakeResol(h2F,1,1,kTRUE,10);
1889   h->SetXTitle("#eta_{mc}");
1890   h->SetYTitle("(#eta-mc#eta) mean");
1891   h->Draw();
1892   h->SetName("deta_mean_vs_mceta");
1893   aFolderObj->Add(h);
1894
1895   fRecMCTrackHist1->GetAxis(0)->SetRange(1,fRecMCTrackHist1->GetAxis(0)->GetNbins());
1896
1897   } // end use MC info
1898
1899   // export objects to analysis folder
1900   fAnalysisFolder = ExportToFolder(aFolderObj);
1901
1902   // delete only TObjArray
1903   if(aFolderObj) delete aFolderObj;
1904 }
1905
1906 //_____________________________________________________________________________
1907 TFolder* AlidNdPtAnalysisPbPb::ExportToFolder(TObjArray * const array)
1908 {
1909   // recreate folder avery time and export objects to new one
1910   //
1911   AlidNdPtAnalysisPbPb * comp=this;
1912   TFolder *folder = comp->GetAnalysisFolder();
1913
1914   TString name, title;
1915   TFolder *newFolder = 0;
1916   Int_t i = 0;
1917   Int_t size = array->GetSize();
1918
1919   if(folder) {
1920      // get name and title from old folder
1921      name = folder->GetName();
1922      title = folder->GetTitle();
1923
1924          // delete old one
1925      delete folder;
1926
1927          // create new one
1928      newFolder = CreateFolder(name.Data(),title.Data());
1929      newFolder->SetOwner();
1930
1931          // add objects to folder
1932      while(i < size) {
1933            newFolder->Add(array->At(i));
1934            i++;
1935          }
1936   }
1937
1938 return newFolder;
1939 }
1940
1941 //_____________________________________________________________________________
1942 TFolder* AlidNdPtAnalysisPbPb::CreateFolder(TString name,TString title) {
1943 // create folder for analysed histograms
1944 //
1945 TFolder *folder = 0;
1946   folder = new TFolder(name.Data(),title.Data());
1947
1948   return folder;
1949 }