PWG1/TPC/AliPerformanceEff.cxx

   1 //------------------------------------------------------------------------------\r
   2 // Implementation of AliPerformanceEff class. It keeps information from \r
   3 // comparison of reconstructed and MC particle tracks. In addtion, \r
   4 // it keeps selection cuts used during comparison. The comparison \r
   5 // information is stored in the ROOT histograms. Analysis of these \r
   6 // histograms can be done by using Analyse() class function. The result of \r
   7 // the analysis (histograms/graphs) are stored in the folder which is \r
   8 // a data member of AliPerformanceEff.\r
   9 // \r
  10 // Author: J.Otwinowski 04/02/2008 \r
  11 //------------------------------------------------------------------------------\r
  12 \r
  13 /*\r
  14  \r
  15   // after running comparison task, read the file, and get component\r
  16   gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C");\r
  17   LoadMyLibs();\r
  18   TFile f("Output.root");\r
  19   AliPerformanceEff * compObj = (AliPerformanceEff*)coutput->FindObject("AliPerformanceEff");\r
  20 \r
  21   // Analyse comparison data\r
  22   compObj->Analyse();\r
  23 \r
  24   // the output histograms/graphs will be stored in the folder "folderEff" \r
  25   compObj->GetAnalysisFolder()->ls("*");\r
  26 \r
  27   // user can save whole comparison object (or only folder with anlysed histograms) \r
  28   // in the seperate output file (e.g.)\r
  29   TFile fout("Analysed_Eff.root","recreate");\r
  30   compObj->Write(); // compObj->GetAnalysisFolder()->Write();\r
  31   fout.Close();\r
  32 \r
  33 */\r
  34 \r
  35 #include <TAxis.h>\r
  36 #include <TH1D.h>\r
  37 #include "THnSparse.h"\r
  38 \r
  39 // \r
  40 #include "AliESDtrack.h"\r
  41 #include "AliRecInfoCuts.h" \r
  42 #include "AliMCInfoCuts.h" \r
  43 #include "AliLog.h" \r
  44 #include "AliESDVertex.h" \r
  45 #include "AliExternalTrackParam.h" \r
  46 #include "AliTracker.h" \r
  47 #include "AliESDEvent.h" \r
  48 #include "AliMCEvent.h" \r
  49 #include "AliMCParticle.h" \r
  50 #include "AliHeader.h" \r
  51 #include "AliGenEventHeader.h" \r
  52 #include "AliStack.h" \r
  53 #include "AliPerformanceEff.h" \r
  54 \r
  55 using namespace std;\r
  56 \r
  57 ClassImp(AliPerformanceEff)\r
  58 \r
  59 //_____________________________________________________________________________\r
  60 AliPerformanceEff::AliPerformanceEff():\r
  61   AliPerformanceObject("AliPerformanceEff"),\r
  62 \r
  63   // histograms\r
  64   fEffHisto(0),\r
  65   fEffSecHisto(0),\r
  66 \r
  67   // Cuts \r
  68   fCutsRC(0), \r
  69   fCutsMC(0),\r
  70 \r
  71   // histogram folder \r
  72   fAnalysisFolder(0)\r
  73 {\r
  74   // default consttructor       \r
  75   Init();\r
  76 }\r
  77 \r
  78 //_____________________________________________________________________________\r
  79 AliPerformanceEff::AliPerformanceEff(Char_t* name="AliPerformanceEff",Char_t*title="AliPerformanceEff",Int_t analysisMode=0, Bool_t hptGenerator=kFALSE):\r
  80   AliPerformanceObject(name,title),\r
  81 \r
  82   // histograms\r
  83   fEffHisto(0),\r
  84   fEffSecHisto(0),\r
  85 \r
  86   // Cuts \r
  87   fCutsRC(0), \r
  88   fCutsMC(0),\r
  89 \r
  90   // histogram folder \r
  91   fAnalysisFolder(0)\r
  92 {\r
  93   // named constructor\r
  94   //\r
  95   SetAnalysisMode(analysisMode);\r
  96   SetHptGenerator(hptGenerator);\r
  97 \r
  98   Init();\r
  99 }\r
 100 \r
 101 \r
 102 //_____________________________________________________________________________\r
 103 AliPerformanceEff::~AliPerformanceEff()\r
 104 {\r
 105 // destructor\r
 106 \r
 107   if(fEffHisto)  delete  fEffHisto; fEffHisto=0;\r
 108   if(fEffSecHisto)  delete  fEffSecHisto; fEffSecHisto=0;\r
 109   if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0;\r
 110 }\r
 111 \r
 112 //_____________________________________________________________________________\r
 113 void AliPerformanceEff::Init()\r
 114 {\r
 115   // Init histograms\r
 116   //\r
 117   // set pt bins\r
 118   Int_t nPtBins = 50;\r
 119   Double_t ptMin = 1.e-2, ptMax = 10.;\r
 120 \r
 121   Double_t *binsPt = 0;\r
 122   if (IsHptGenerator())  { \r
 123     nPtBins = 100; ptMax = 100.;\r
 124     binsPt = CreateLogAxis(nPtBins,ptMin,ptMax);\r
 125   } else {\r
 126     binsPt = CreateLogAxis(nPtBins,ptMin,ptMax);\r
 127   }\r
 128 \r
 129   /*\r
 130   Int_t nPtBins = 31;\r
 131   Double_t binsPt[32] = {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.7,0.8,0.9,1.0,1.2,1.4,1.6,1.8,2.0,2.25,2.5,2.75,3.,3.5,4.,5.,6.,8.,10.};\r
 132   Double_t ptMin = 0., ptMax = 10.;\r
 133 \r
 134   if(IsHptGenerator() == kTRUE) {\r
 135     nPtBins = 100;\r
 136     ptMin = 0.; ptMax = 100.;\r
 137   }\r
 138   */\r
 139 \r
 140   //mceta:mcphi:mcpt:pid:recStatus:findable\r
 141   Int_t binsEffHisto[6]={30,144,nPtBins,5,2,2};\r
 142   Double_t minEffHisto[6]={-1.5,0.,ptMin,0.,0.,0.};\r
 143   Double_t maxEffHisto[6]={ 1.5,2.*TMath::Pi(), ptMax,5.,2.,2.};\r
 144 \r
 145   fEffHisto = new THnSparseF("fEffHisto","mceta:mcphi:mcpt:pid:recStatus:findable",6,binsEffHisto,minEffHisto,maxEffHisto);\r
 146   fEffHisto->SetBinEdges(2,binsPt);\r
 147 \r
 148   fEffHisto->GetAxis(0)->SetTitle("#eta_{mc}");\r
 149   fEffHisto->GetAxis(1)->SetTitle("#phi_{mc} (rad)");\r
 150   fEffHisto->GetAxis(2)->SetTitle("p_{Tmc} (GeV/c)");\r
 151   fEffHisto->GetAxis(3)->SetTitle("pid");\r
 152   fEffHisto->GetAxis(4)->SetTitle("recStatus");\r
 153   fEffHisto->GetAxis(5)->SetTitle("findable");\r
 154   fEffHisto->Sumw2();\r
 155 \r
 156   //mceta:mcphi:mcpt:pid:recStatus:findable:mcR:mother_phi:mother_eta\r
 157   Int_t binsEffSecHisto[9]={30,60,nPtBins,5,2,2,100,60,30};\r
 158   Double_t minEffSecHisto[9]={-1.5,0.,ptMin,0.,0.,0.,0.,0.,-1.5};\r
 159   Double_t maxEffSecHisto[9]={ 1.5,2.*TMath::Pi(), ptMax,5.,2.,2.,200,2.*TMath::Pi(),1.5};\r
 160 \r
 161   fEffSecHisto = new THnSparseF("fEffSecHisto","mceta:mcphi:mcpt:pid:recStatus:findable:mcR:mother_phi:mother_eta",9,binsEffSecHisto,minEffSecHisto,maxEffSecHisto);\r
 162   fEffSecHisto->SetBinEdges(2,binsPt);\r
 163 \r
 164   fEffSecHisto->GetAxis(0)->SetTitle("#eta_{mc}");\r
 165   fEffSecHisto->GetAxis(1)->SetTitle("#phi_{mc} (rad)");\r
 166   fEffSecHisto->GetAxis(2)->SetTitle("p_{Tmc} (GeV/c)");\r
 167   fEffSecHisto->GetAxis(3)->SetTitle("pid");\r
 168   fEffSecHisto->GetAxis(4)->SetTitle("recStatus");\r
 169   fEffSecHisto->GetAxis(5)->SetTitle("findable");\r
 170   fEffSecHisto->GetAxis(6)->SetTitle("mcR (cm)");\r
 171   fEffSecHisto->GetAxis(7)->SetTitle("mother_phi (rad)");\r
 172   fEffSecHisto->GetAxis(8)->SetTitle("mother_eta");\r
 173   fEffSecHisto->Sumw2();\r
 174 \r
 175   // init cuts\r
 176   if(!fCutsMC) \r
 177     AliDebug(AliLog::kError, "ERROR: Cannot find AliMCInfoCuts object");\r
 178   if(!fCutsRC) \r
 179     AliDebug(AliLog::kError, "ERROR: Cannot find AliRecInfoCuts object");\r
 180 \r
 181   // init folder\r
 182   fAnalysisFolder = CreateFolder("folderEff","Analysis Efficiency Folder");\r
 183 }\r
 184 \r
 185 //_____________________________________________________________________________\r
 186 void AliPerformanceEff::ProcessTPC(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent)\r
 187 {\r
 188   // Fill TPC only efficiency comparison information \r
 189   Int_t *labelsRec =  new Int_t[esdEvent->GetNumberOfTracks()];\r
 190   if(!labelsRec) \r
 191      AliDebug(AliLog::kError, "Cannot create labelsRec");\r
 192 \r
 193   Int_t *labelsAllRec =  new Int_t[esdEvent->GetNumberOfTracks()];\r
 194   if(!labelsAllRec) \r
 195      AliDebug(AliLog::kError, "Cannot create labelsAllRec");\r
 196 \r
 197   // loop over rec. tracks\r
 198   AliESDtrack *track=0;\r
 199   for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) \r
 200   { \r
 201     track = esdEvent->GetTrack(iTrack);\r
 202     if(!track) continue;\r
 203     if(track->Charge()==0) continue;\r
 204     Int_t label = TMath::Abs(track->GetLabel()); \r
 205     labelsAllRec[iTrack]=label;\r
 206 \r
 207     // TPC only\r
 208     if(IsRecTPC(track) != 0) \r
 209       labelsRec[iTrack]=label;\r
 210   }\r
 211 \r
 212   // \r
 213   // MC histograms for efficiency studies\r
 214   //\r
 215   if(!mcEvent) return;\r
 216  \r
 217   AliStack *stack = mcEvent->Stack();\r
 218   if (!stack) {\r
 219     AliDebug(AliLog::kError, "Stack not available");\r
 220     return;\r
 221   }\r
 222 \r
 223   //Int_t nPart  = stack->GetNtrack();\r
 224   Int_t nPart  = stack->GetNprimary();\r
 225   for (Int_t iMc = 0; iMc < nPart; ++iMc) \r
 226   {\r
 227     TParticle* particle = stack->Particle(iMc);\r
 228     if (!particle) continue;\r
 229     if (!particle->GetPDG()) continue; \r
 230     if (particle->GetPDG()->Charge() == 0.0) continue;\r
 231       \r
 232     // physical primary\r
 233     Bool_t prim = stack->IsPhysicalPrimary(iMc);\r
 234     if(!prim) continue;\r
 235 \r
 236     Bool_t findable = kFALSE;\r
 237     for(Int_t iRec=0; iRec<esdEvent->GetNumberOfTracks(); ++iRec) \r
 238     {\r
 239       // check findable\r
 240       if(iMc == labelsAllRec[iRec]) \r
 241       {\r
 242         findable = IsFindable(mcEvent,iMc);\r
 243         break;\r
 244       }\r
 245     }  \r
 246 \r
 247     Bool_t recStatus = kFALSE;\r
 248     for(Int_t iRec=0; iRec<esdEvent->GetNumberOfTracks(); ++iRec) \r
 249     {\r
 250       // check reconstructed\r
 251       if(iMc == labelsRec[iRec]) \r
 252       {\r
 253         recStatus = kTRUE;\r
 254         break;\r
 255       }\r
 256     }\r
 257 \r
 258     // Only 5 charged particle species (e,mu,pi,K,p)\r
 259     if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) continue; \r
 260 \r
 261     // transform Pdg to Pid\r
 262     Int_t pid = TransformToPID(particle);\r
 263 \r
 264     Float_t mceta =  particle->Eta();\r
 265     Float_t mcphi =  particle->Phi();\r
 266     if(mcphi<0) mcphi += 2.*TMath::Pi();\r
 267     Float_t mcpt = particle->Pt();\r
 268 \r
 269 \r
 270     // Fill histograms\r
 271     Double_t vEffHisto[6] = {mceta, mcphi, mcpt, pid, recStatus, findable}; \r
 272     fEffHisto->Fill(vEffHisto);\r
 273   }\r
 274 \r
 275   if(labelsRec) delete [] labelsRec; labelsRec = 0;\r
 276   if(labelsAllRec) delete [] labelsAllRec; labelsAllRec = 0;\r
 277 }\r
 278 \r
 279 //_____________________________________________________________________________\r
 280 void AliPerformanceEff::ProcessTPCSec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent)\r
 281 {\r
 282   // Fill TPC only efficiency comparison information for secondaries\r
 283   Int_t *labelsRec =  new Int_t[esdEvent->GetNumberOfTracks()];\r
 284   if(!labelsRec) \r
 285      AliDebug(AliLog::kError, "Cannot create labelsRec");\r
 286 \r
 287   Int_t *labelsAllRec =  new Int_t[esdEvent->GetNumberOfTracks()];\r
 288   if(!labelsAllRec) \r
 289      AliDebug(AliLog::kError, "Cannot create labelsAllRec");\r
 290 \r
 291   // loop over rec. tracks\r
 292   AliESDtrack *track=0;\r
 293   Int_t multAll=0, multRec=0;\r
 294   for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) \r
 295   { \r
 296     track = esdEvent->GetTrack(iTrack);\r
 297     if(!track) continue;\r
 298     if(track->Charge()==0) continue;\r
 299     Int_t label = TMath::Abs(track->GetLabel()); \r
 300     labelsAllRec[multAll]=label;\r
 301     multAll++;\r
 302 \r
 303     // TPC only\r
 304     if(IsRecTPC(track) != 0) {\r
 305       labelsRec[multRec]=label;\r
 306       multRec++;\r
 307     }\r
 308   }\r
 309 \r
 310   // \r
 311   // MC histograms for efficiency studies\r
 312   //\r
 313   if(!mcEvent) return;\r
 314  \r
 315   AliStack *stack = mcEvent->Stack();\r
 316   if (!stack) {\r
 317     AliDebug(AliLog::kError, "Stack not available");\r
 318     return;\r
 319   }\r
 320 \r
 321   Int_t nPart  = stack->GetNtrack();\r
 322   //Int_t nPart  = stack->GetNprimary();\r
 323   for (Int_t iMc = 0; iMc < nPart; ++iMc) \r
 324   {\r
 325     TParticle* particle = stack->Particle(iMc);\r
 326     if (!particle) continue;\r
 327     if (!particle->GetPDG()) continue; \r
 328     if (particle->GetPDG()->Charge() == 0.0) continue;\r
 329       \r
 330     // physical primary\r
 331     Bool_t prim = stack->IsPhysicalPrimary(iMc);\r
 332 \r
 333     // only secondaries which can be reconstructed at TPC\r
 334     if(prim) continue;\r
 335 \r
 336     //Float_t radius = TMath::Sqrt(particle->Vx()*particle->Vx()+particle->Vy()*particle->Vy()+particle->Vz()*particle->Vz());\r
 337     //if(radius > fCutsMC->GetMaxR()) continue;\r
 338 \r
 339     // only secondary electrons from gamma conversion\r
 340     //if( TMath::Abs(particle->GetPdgCode())!=fCutsMC->GetEM() ||   particle->GetUniqueID() != 5) continue;\r
 341 \r
 342     Bool_t findable = kFALSE;\r
 343     for(Int_t iRec=0; iRec<multAll; ++iRec) \r
 344     {\r
 345       // check findable\r
 346       if(iMc == labelsAllRec[iRec]) \r
 347       {\r
 348         findable = IsFindable(mcEvent,iMc);\r
 349         break;\r
 350       }\r
 351     }  \r
 352 \r
 353     Bool_t recStatus = kFALSE;\r
 354     for(Int_t iRec=0; iRec<multRec; ++iRec) \r
 355     {\r
 356       // check reconstructed\r
 357       if(iMc == labelsRec[iRec]) \r
 358       {\r
 359         recStatus = kTRUE;\r
 360         break;\r
 361       }\r
 362     }\r
 363 \r
 364     // Only 5 charged particle species (e,mu,pi,K,p)\r
 365     if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) continue; \r
 366 \r
 367     // transform Pdg to Pid\r
 368     Int_t pid = TransformToPID(particle);\r
 369 \r
 370     Float_t mceta =  particle->Eta();\r
 371     Float_t mcphi =  particle->Phi();\r
 372     if(mcphi<0) mcphi += 2.*TMath::Pi();\r
 373     Float_t mcpt = particle->Pt();\r
 374     Float_t mcR = particle->R();\r
 375 \r
 376     // get info about mother\r
 377     Int_t motherLabel = particle->GetMother(0);\r
 378     if(motherLabel < 0) continue;\r
 379     TParticle *mother = stack->Particle(motherLabel);\r
 380     if(!mother) continue; \r
 381 \r
 382     Float_t mother_eta = mother->Eta();\r
 383     Float_t mother_phi = mother->Phi();\r
 384     if(mother_phi<0) mother_phi += 2.*TMath::Pi();\r
 385 \r
 386     // Fill histograms\r
 387     Double_t vEffSecHisto[9] = { mceta, mcphi, mcpt, pid, recStatus, findable, mcR, mother_phi, mother_eta }; \r
 388     fEffSecHisto->Fill(vEffSecHisto);\r
 389   }\r
 390 \r
 391   if(labelsRec) delete [] labelsRec; labelsRec = 0;\r
 392   if(labelsAllRec) delete [] labelsAllRec; labelsAllRec = 0;\r
 393 }\r
 394 \r
 395 \r
 396 \r
 397 \r
 398 //_____________________________________________________________________________\r
 399 void AliPerformanceEff::ProcessTPCITS(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent)\r
 400 {\r
 401   // Fill efficiency comparison information\r
 402   Int_t *labelsRec =  new Int_t[esdEvent->GetNumberOfTracks()];\r
 403   if(!labelsRec) \r
 404      AliDebug(AliLog::kError, "Cannot create labelsRec");\r
 405 \r
 406   Int_t *labelsAllRec =  new Int_t[esdEvent->GetNumberOfTracks()];\r
 407   if(!labelsAllRec) \r
 408      AliDebug(AliLog::kError, "Cannot create labelsAllRec");\r
 409 \r
 410   // loop over rec. tracks\r
 411   AliESDtrack *track=0;\r
 412   for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) \r
 413   { \r
 414     track = esdEvent->GetTrack(iTrack);\r
 415     if(!track) continue;\r
 416     if(track->Charge()==0) continue;\r
 417     Int_t label = TMath::Abs(track->GetLabel()); \r
 418     labelsAllRec[iTrack]=label;\r
 419 \r
 420     // iTPC+ITS\r
 421     if(IsRecTPCITS(track) != 0) \r
 422       labelsRec[iTrack]=label;\r
 423   }\r
 424 \r
 425   // \r
 426   // MC histograms for efficiency studies\r
 427   //\r
 428   if(!mcEvent) return;\r
 429  \r
 430   AliStack *stack = mcEvent->Stack();\r
 431   if (!stack) {\r
 432     AliDebug(AliLog::kError, "Stack not available");\r
 433     return;\r
 434   }\r
 435 \r
 436   //Int_t nPart  = stack->GetNtrack();\r
 437   Int_t nPart  = stack->GetNprimary();\r
 438   for (Int_t iMc = 0; iMc < nPart; ++iMc) \r
 439   {\r
 440     TParticle* particle = stack->Particle(iMc);\r
 441     if (!particle) continue;\r
 442     if (!particle->GetPDG()) continue; \r
 443     if (particle->GetPDG()->Charge() == 0.0) continue;\r
 444       \r
 445     // physical primary\r
 446     Bool_t prim = stack->IsPhysicalPrimary(iMc);\r
 447     if(!prim) continue;\r
 448 \r
 449     Bool_t findable = kFALSE;\r
 450     for(Int_t iRec=0; iRec<esdEvent->GetNumberOfTracks(); ++iRec) \r
 451     {\r
 452       // check findable\r
 453       if(iMc == labelsAllRec[iRec]) \r
 454       {\r
 455         findable = IsFindable(mcEvent,iMc);\r
 456         break;\r
 457       }\r
 458     }  \r
 459 \r
 460     Bool_t recStatus = kFALSE;\r
 461     for(Int_t iRec=0; iRec<esdEvent->GetNumberOfTracks(); ++iRec) \r
 462     {\r
 463       // check reconstructed\r
 464       if(iMc == labelsRec[iRec]) \r
 465       {\r
 466         recStatus = kTRUE;\r
 467         break;\r
 468       }\r
 469     }\r
 470 \r
 471     // Only 5 charged particle species (e,mu,pi,K,p)\r
 472     if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) continue; \r
 473 \r
 474     // transform Pdg to Pid\r
 475     Int_t pid = TransformToPID(particle);\r
 476 \r
 477     Float_t mceta =  particle->Eta();\r
 478     Float_t mcphi =  particle->Phi();\r
 479     if(mcphi<0) mcphi += 2.*TMath::Pi();\r
 480     Float_t mcpt = particle->Pt();\r
 481 \r
 482     // Fill histograms\r
 483     Double_t vEffHisto[6] = { mceta, mcphi, mcpt, pid, recStatus, findable}; \r
 484     fEffHisto->Fill(vEffHisto);\r
 485   }\r
 486 \r
 487   if(labelsRec) delete [] labelsRec; labelsRec = 0;\r
 488   if(labelsAllRec) delete [] labelsAllRec; labelsAllRec = 0;\r
 489 }\r
 490 \r
 491 //_____________________________________________________________________________\r
 492 void AliPerformanceEff::ProcessConstrained(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent)\r
 493 {\r
 494   // Process comparison information \r
 495   Int_t *labelsRec =  new Int_t[esdEvent->GetNumberOfTracks()];\r
 496   if(!labelsRec) \r
 497      AliDebug(AliLog::kError, "Cannot create labelsRec");\r
 498 \r
 499   Int_t *labelsAllRec =  new Int_t[esdEvent->GetNumberOfTracks()];\r
 500   if(!labelsAllRec) \r
 501      AliDebug(AliLog::kError, "Cannot create labelsAllRec");\r
 502 \r
 503   // loop over rec. tracks\r
 504   AliESDtrack *track=0;\r
 505   for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) \r
 506   { \r
 507     track = esdEvent->GetTrack(iTrack);\r
 508     if(!track) continue;\r
 509     if(track->Charge()==0) continue;\r
 510     Int_t label = TMath::Abs(track->GetLabel()); \r
 511     labelsAllRec[iTrack]=label;\r
 512 \r
 513     // Constrained\r
 514     if(IsRecConstrained(track) != 0) \r
 515       labelsRec[iTrack]=label;\r
 516 \r
 517   }\r
 518 \r
 519   // \r
 520   // MC histograms for efficiency studies\r
 521   //\r
 522   if(!mcEvent) return;\r
 523  \r
 524   AliStack *stack = mcEvent->Stack();\r
 525   if (!stack) {\r
 526     AliDebug(AliLog::kError, "Stack not available");\r
 527     return;\r
 528   }\r
 529 \r
 530   //Int_t nPart  = stack->GetNtrack();\r
 531   Int_t nPart  = stack->GetNprimary();\r
 532   for (Int_t iMc = 0; iMc < nPart; ++iMc) \r
 533   {\r
 534     TParticle* particle = stack->Particle(iMc);\r
 535     if (!particle) continue;\r
 536     if (!particle->GetPDG()) continue; \r
 537     if (particle->GetPDG()->Charge() == 0.0) continue;\r
 538       \r
 539     // physical primary\r
 540     Bool_t prim = stack->IsPhysicalPrimary(iMc);\r
 541     if(!prim) continue;\r
 542 \r
 543     Bool_t findable = kFALSE;\r
 544     for(Int_t iRec=0; iRec<esdEvent->GetNumberOfTracks(); ++iRec) \r
 545     {\r
 546       // check findable\r
 547       if(iMc == labelsAllRec[iRec]) \r
 548       {\r
 549         findable = IsFindable(mcEvent,iMc);\r
 550         break;\r
 551       }\r
 552     }  \r
 553 \r
 554     Bool_t recStatus = kFALSE;\r
 555     for(Int_t iRec=0; iRec<esdEvent->GetNumberOfTracks(); ++iRec) \r
 556     {\r
 557       // check reconstructed\r
 558       if(iMc == labelsRec[iRec]) \r
 559       {\r
 560         recStatus = kTRUE;\r
 561         break;\r
 562       }\r
 563     }\r
 564 \r
 565     // Only 5 charged particle species (e,mu,pi,K,p)\r
 566     if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) continue; \r
 567 \r
 568     // transform Pdg to Pid\r
 569     Int_t pid = TransformToPID(particle);\r
 570 \r
 571     Float_t mceta =  particle->Eta();\r
 572     Float_t mcphi =  particle->Phi();\r
 573     if(mcphi<0) mcphi += 2.*TMath::Pi();\r
 574     Float_t mcpt = particle->Pt();\r
 575 \r
 576     // Fill histograms\r
 577     Double_t vEffHisto[6] = { mceta, mcphi, mcpt, pid, recStatus, findable}; \r
 578     fEffHisto->Fill(vEffHisto);\r
 579   }\r
 580 \r
 581   if(labelsRec) delete [] labelsRec; labelsRec = 0;\r
 582   if(labelsAllRec) delete [] labelsAllRec; labelsAllRec = 0;\r
 583 }\r
 584 \r
 585 //_____________________________________________________________________________\r
 586 void AliPerformanceEff::Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent, AliESDfriend *const esdFriend, const Bool_t bUseMC, const Bool_t bUseESDfriend)\r
 587 {\r
 588   // Process comparison information \r
 589   //\r
 590   if(!esdEvent) \r
 591   {\r
 592     Error("Exec","esdEvent not available");\r
 593     return;\r
 594   }\r
 595   AliHeader* header = 0;\r
 596   AliGenEventHeader* genHeader = 0;\r
 597   AliStack* stack = 0;\r
 598   TArrayF vtxMC(3);\r
 599   \r
 600   if(bUseMC)\r
 601   {\r
 602     if(!mcEvent) {\r
 603       Error("Exec","mcEvent not available");\r
 604       return;\r
 605     }\r
 606     // get MC event header\r
 607     header = mcEvent->Header();\r
 608     if (!header) {\r
 609       Error("Exec","Header not available");\r
 610       return;\r
 611     }\r
 612     // MC particle stack\r
 613     stack = mcEvent->Stack();\r
 614     if (!stack) {\r
 615       Error("Exec","Stack not available");\r
 616       return;\r
 617     }\r
 618     // get MC vertex\r
 619     genHeader = header->GenEventHeader();\r
 620     if (!genHeader) {\r
 621       Error("Exec","Could not retrieve genHeader from Header");\r
 622       return;\r
 623     }\r
 624     genHeader->PrimaryVertex(vtxMC);\r
 625   } \r
 626   else {\r
 627     Error("Exec","MC information required!");\r
 628     return;\r
 629   } \r
 630 \r
 631   // use ESD friends\r
 632   if(bUseESDfriend) {\r
 633     if(!esdFriend) {\r
 634       Error("Exec","esdFriend not available");\r
 635       return;\r
 636     }\r
 637   }\r
 638 \r
 639   //\r
 640   //  Process events\r
 641   //\r
 642   if(GetAnalysisMode() == 0) ProcessTPC(mcEvent,esdEvent);\r
 643   else if(GetAnalysisMode() == 1) ProcessTPCITS(mcEvent,esdEvent);\r
 644   else if(GetAnalysisMode() == 2) ProcessConstrained(mcEvent,esdEvent);\r
 645   else if(GetAnalysisMode() == 5) ProcessTPCSec(mcEvent,esdEvent);\r
 646   else {\r
 647     printf("ERROR: AnalysisMode %d \n",fAnalysisMode);\r
 648     return;\r
 649   }\r
 650 }\r
 651 \r
 652 //_____________________________________________________________________________\r
 653 Int_t AliPerformanceEff::TransformToPID(TParticle *particle) \r
 654 {\r
 655 // transform Pdg to Pid\r
 656 // Pdg convension is different for hadrons and leptons \r
 657 // (e.g. K+/K- = 321/-321; e+/e- = -11/11 ) \r
 658 \r
 659   Int_t pid = -1;\r
 660   if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetEM() ) pid = 0; \r
 661   if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetMuM() ) pid = 1; \r
 662   if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetPiP() ) pid = 2; \r
 663   if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetKP() ) pid = 3; \r
 664   if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetProt() ) pid = 4; \r
 665 \r
 666 return pid;\r
 667 }\r
 668 \r
 669 //_____________________________________________________________________________\r
 670 Bool_t AliPerformanceEff::IsFindable(const AliMCEvent *mcEvent, Int_t label) \r
 671 {\r
 672 //\r
 673 // Findfindable tracks\r
 674 //\r
 675 if(!mcEvent) return kFALSE;\r
 676 \r
 677   AliMCParticle *mcParticle = (AliMCParticle*) mcEvent->GetTrack(label);\r
 678   if(!mcParticle) return kFALSE;\r
 679 \r
 680   Int_t counter; \r
 681   Float_t tpcTrackLength = mcParticle->GetTPCTrackLength(AliTracker::GetBz(),0.05,counter,3.0); \r
 682   //printf("tpcTrackLength %f \n", tpcTrackLength);\r
 683 \r
 684 return (tpcTrackLength>fCutsMC->GetMinTrackLength());    \r
 685 }\r
 686 \r
 687 //_____________________________________________________________________________\r
 688 Bool_t AliPerformanceEff::IsRecTPC(AliESDtrack *esdTrack) \r
 689 {\r
 690 //\r
 691 // Check whether track is reconstructed in TPC\r
 692 //\r
 693 if(!esdTrack) return kFALSE;\r
 694 \r
 695   const AliExternalTrackParam *track = esdTrack->GetTPCInnerParam();\r
 696   if(!track) return kFALSE;\r
 697 \r
 698   Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z\r
 699   esdTrack->GetImpactParametersTPC(dca,cov);\r
 700 \r
 701   Bool_t recStatus = kFALSE;\r
 702   if(esdTrack->GetTPCNcls()>fCutsRC->GetMinNClustersTPC()) recStatus = kTRUE; \r
 703 \r
 704   /*\r
 705   if( TMath::Abs(dca[0])<fCutsRC->GetMaxDCAToVertexXY() && \r
 706       TMath::Abs(dca[1])<fCutsRC->GetMaxDCAToVertexZ())\r
 707   {\r
 708     recStatus = kTRUE;\r
 709   }\r
 710   */\r
 711 \r
 712 return recStatus;\r
 713 }\r
 714 \r
 715 //_____________________________________________________________________________\r
 716 Bool_t AliPerformanceEff::IsRecTPCITS(AliESDtrack *esdTrack) \r
 717 {\r
 718 //\r
 719 // Check whether track is reconstructed in TPCITS\r
 720 //\r
 721 if(!esdTrack) return kFALSE;\r
 722 \r
 723   Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z\r
 724   esdTrack->GetImpactParameters(dca,cov);\r
 725 \r
 726   Bool_t recStatus = kFALSE;\r
 727 \r
 728   if ((esdTrack->GetStatus()&AliESDtrack::kTPCrefit)==0) return kFALSE; // TPC refit\r
 729   if (esdTrack->GetTPCNcls()<fCutsRC->GetMinNClustersTPC()) return kFALSE; // min. nb. TPC clusters\r
 730   //if ((esdTrack->GetStatus()&AliESDtrack::kITSrefit)==0) return kFALSE; // ITS refit\r
 731   //Int_t clusterITS[200];\r
 732   //if(esdTrack->GetITSclusters(clusterITS)<fCutsRC->GetMinNClustersITS()) return kFALSE;  // min. nb. ITS clusters\r
 733 \r
 734   recStatus = kTRUE;\r
 735   /*\r
 736   if(TMath::Abs(dca[0])<fCutsRC->GetMaxDCAToVertexXY() && \r
 737      TMath::Abs(dca[1])<fCutsRC->GetMaxDCAToVertexZ())\r
 738   {\r
 739     recStatus = kTRUE;\r
 740   }\r
 741   */\r
 742 \r
 743 return recStatus;\r
 744 }\r
 745 \r
 746 //_____________________________________________________________________________\r
 747 Bool_t AliPerformanceEff::IsRecConstrained(AliESDtrack *esdTrack) \r
 748 {\r
 749 //\r
 750 // Check whether track is reconstructed in IsRecConstrained\r
 751 //\r
 752   if(!esdTrack) return kFALSE;\r
 753 \r
 754   const AliExternalTrackParam * track = esdTrack->GetConstrainedParam();\r
 755   if(!track) return kFALSE;\r
 756 \r
 757   Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z\r
 758   esdTrack->GetImpactParameters(dca,cov);\r
 759   //Int_t label = TMath::Abs(esdTrack->GetLabel()); \r
 760 \r
 761   Bool_t recStatus = kFALSE;\r
 762 \r
 763   if ((esdTrack->GetStatus()&AliESDtrack::kTPCrefit)==0) return kFALSE; // TPC refit\r
 764   if (esdTrack->GetTPCNcls()<fCutsRC->GetMinNClustersTPC()) return kFALSE; // min. nb. TPC clusters\r
 765   Int_t clusterITS[200];\r
 766   if(esdTrack->GetITSclusters(clusterITS)<fCutsRC->GetMinNClustersITS()) return kFALSE;  // min. nb. ITS clusters\r
 767 \r
 768   recStatus = kTRUE;\r
 769 \r
 770   /*\r
 771   if(TMath::Abs(dca[0])<fCutsRC->GetMaxDCAToVertexXY() && \r
 772      TMath::Abs(dca[1])<fCutsRC->GetMaxDCAToVertexZ())\r
 773   {\r
 774     recStatus = kTRUE;\r
 775   }\r
 776   */\r
 777 \r
 778 return recStatus;\r
 779 }\r
 780 \r
 781 //_____________________________________________________________________________\r
 782 Long64_t AliPerformanceEff::Merge(TCollection* const list) \r
 783 {\r
 784   // Merge list of objects (needed by PROOF)\r
 785 \r
 786   if (!list)\r
 787   return 0;\r
 788 \r
 789   if (list->IsEmpty())\r
 790   return 1;\r
 791 \r
 792   TIterator* iter = list->MakeIterator();\r
 793   TObject* obj = 0;\r
 794 \r
 795   // collection of generated histograms\r
 796 \r
 797   Int_t count=0;\r
 798   while((obj = iter->Next()) != 0) \r
 799   {\r
 800     AliPerformanceEff* entry = dynamic_cast<AliPerformanceEff*>(obj);\r
 801     if (entry == 0) continue; \r
 802   \r
 803      fEffHisto->Add(entry->fEffHisto);\r
 804      fEffSecHisto->Add(entry->fEffSecHisto);\r
 805   count++;\r
 806   }\r
 807 \r
 808 return count;\r
 809 }\r
 810  \r
 811 //_____________________________________________________________________________\r
 812 void AliPerformanceEff::Analyse() \r
 813 {\r
 814   // Analyse comparison information and store output histograms\r
 815   // in the folder "folderEff" \r
 816   //\r
 817   TH1::AddDirectory(kFALSE);\r
 818   TObjArray *aFolderObj = new TObjArray;\r
 819   char title[256];\r
 820 \r
 821   //\r
 822   // efficiency vs pt\r
 823   //\r
 824 \r
 825   if(GetAnalysisMode() != 5) {\r
 826 \r
 827   fEffHisto->GetAxis(0)->SetRangeUser(-0.9,0.9); // eta range\r
 828   fEffHisto->GetAxis(2)->SetRangeUser(0.1,10.); // pt range\r
 829 \r
 830   // rec efficiency vs pt\r
 831   TH1D *ptAll = fEffHisto->Projection(2);\r
 832 \r
 833   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.);  // reconstructed \r
 834   TH1D *ptRec = fEffHisto->Projection(2);\r
 835   TH1D *ptRecc = (TH1D*)ptRec->Clone();\r
 836   ptRecc->Divide(ptRec,ptAll,1,1,"B");\r
 837   ptRecc->SetName("ptRecEff");\r
 838 \r
 839   ptRecc->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle());\r
 840   ptRecc->GetYaxis()->SetTitle("efficiency");\r
 841   sprintf(title,"%s vs %s","rec. efficiency",fEffHisto->GetAxis(2)->GetTitle());\r
 842   ptRecc->SetTitle(title);\r
 843 \r
 844   ptRecc->SetBit(TH1::kLogX);\r
 845   aFolderObj->Add(ptRecc);\r
 846 \r
 847   // rec efficiency vs pid vs pt\r
 848 \r
 849   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
 850   fEffHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions\r
 851 \r
 852   TH1D *ptAllPi = fEffHisto->Projection(2);\r
 853 \r
 854   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
 855   TH1D *ptRecPi = fEffHisto->Projection(2);\r
 856   TH1D *ptRecPic = (TH1D*)ptRecPi->Clone();\r
 857   ptRecPic->Divide(ptRecPi,ptAllPi,1,1,"B");\r
 858   ptRecPic->SetName("ptRecEffPi");\r
 859 \r
 860   ptRecPic->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle());\r
 861   ptRecPic->GetYaxis()->SetTitle("efficiency");\r
 862   sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffHisto->GetAxis(2)->GetTitle());\r
 863   ptRecPic->SetTitle(title);\r
 864 \r
 865   ptRecPic->SetBit(TH1::kLogX);\r
 866   aFolderObj->Add(ptRecPic);\r
 867 \r
 868   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
 869   fEffHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons\r
 870   TH1D *ptAllK = fEffHisto->Projection(2);\r
 871 \r
 872   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
 873   TH1D *ptRecK = fEffHisto->Projection(2);\r
 874 \r
 875   TH1D *ptRecKc = (TH1D*)ptRecK->Clone();\r
 876   ptRecKc->Divide(ptRecK,ptAllK,1,1,"B");\r
 877   ptRecKc->SetName("ptRecEffK");\r
 878 \r
 879   ptRecKc->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle());\r
 880   ptRecKc->GetYaxis()->SetTitle("efficiency");\r
 881   sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffHisto->GetAxis(2)->GetTitle());\r
 882   ptRecKc->SetTitle(title);\r
 883 \r
 884 \r
 885   ptRecKc->SetBit(TH1::kLogX);\r
 886   aFolderObj->Add(ptRecKc);\r
 887 \r
 888   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
 889   fEffHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons\r
 890   TH1D *ptAllP = fEffHisto->Projection(2);\r
 891 \r
 892   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
 893   TH1D *ptRecP = fEffHisto->Projection(2);\r
 894   TH1D *ptRecPc = (TH1D*)ptRecP->Clone();\r
 895   ptRecPc->Divide(ptRecP,ptAllP,1,1,"B");\r
 896   ptRecPc->SetName("ptRecEffP");\r
 897 \r
 898   ptRecPc->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle());\r
 899   ptRecPc->GetYaxis()->SetTitle("efficiency");\r
 900   sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffHisto->GetAxis(2)->GetTitle());\r
 901   ptRecPc->SetTitle(title);\r
 902 \r
 903   ptRecPc->SetBit(TH1::kLogX);\r
 904   aFolderObj->Add(ptRecPc);\r
 905 \r
 906   // findable efficiency vs pt\r
 907 \r
 908   fEffHisto->GetAxis(3)->SetRangeUser(0.,4.); \r
 909   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
 910   fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable\r
 911   TH1D *ptAllF = fEffHisto->Projection(2);\r
 912 \r
 913   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.);\r
 914   fEffHisto->GetAxis(5)->SetRangeUser(1.,1.);\r
 915 \r
 916   TH1D *ptRecF = fEffHisto->Projection(2); // rec findable\r
 917   TH1D *ptRecFc = (TH1D*)ptRecF->Clone();\r
 918   ptRecFc->Divide(ptRecF,ptAllF,1,1,"B");\r
 919   ptRecFc->SetName("ptRecEffF");\r
 920 \r
 921   ptRecFc->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle());\r
 922   ptRecFc->GetYaxis()->SetTitle("efficiency");\r
 923   sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffHisto->GetAxis(2)->GetTitle());\r
 924   ptRecFc->SetTitle(title);\r
 925 \r
 926   ptRecFc->SetBit(TH1::kLogX);\r
 927   aFolderObj->Add(ptRecFc);\r
 928 \r
 929   //\r
 930   // efficiency vs eta\r
 931   //\r
 932 \r
 933   fEffHisto->GetAxis(0)->SetRangeUser(-1.5,1.5); // eta range\r
 934   fEffHisto->GetAxis(2)->SetRangeUser(0.2,10.); // pt range\r
 935   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.);   // all\r
 936   fEffHisto->GetAxis(5)->SetRangeUser(0.,1.);   // all\r
 937 \r
 938   TH1D *etaAll = fEffHisto->Projection(0);\r
 939 \r
 940   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.);  // reconstructed \r
 941   TH1D *etaRec = fEffHisto->Projection(0);\r
 942   TH1D *etaRecc = (TH1D*)etaRec->Clone();\r
 943   etaRecc->Divide(etaRec,etaAll,1,1,"B");\r
 944   etaRecc->SetName("etaRecEff");\r
 945 \r
 946   etaRecc->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle());\r
 947   etaRecc->GetYaxis()->SetTitle("efficiency");\r
 948   sprintf(title,"%s vs %s","rec. efficiency",fEffHisto->GetAxis(0)->GetTitle());\r
 949   etaRecc->SetTitle(title);\r
 950 \r
 951   aFolderObj->Add(etaRecc);\r
 952 \r
 953   // rec efficiency vs pid vs eta\r
 954   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
 955   fEffHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions\r
 956 \r
 957   TH1D *etaAllPi = fEffHisto->Projection(0);\r
 958 \r
 959   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
 960   TH1D *etaRecPi = fEffHisto->Projection(0);\r
 961   TH1D *etaRecPic = (TH1D*)etaRecPi->Clone();\r
 962   etaRecPic->Divide(etaRecPi,etaAllPi,1,1,"B");\r
 963   etaRecPic->SetName("etaRecEffPi");\r
 964 \r
 965   etaRecPic->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle());\r
 966   etaRecPic->GetYaxis()->SetTitle("efficiency");\r
 967   sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffHisto->GetAxis(0)->GetTitle());\r
 968   etaRecPic->SetTitle(title);\r
 969 \r
 970   aFolderObj->Add(etaRecPic);\r
 971 \r
 972   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
 973   fEffHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons\r
 974   TH1D *etaAllK = fEffHisto->Projection(0);\r
 975 \r
 976   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
 977   TH1D *etaRecK = fEffHisto->Projection(0);\r
 978 \r
 979   TH1D *etaRecKc = (TH1D*)etaRecK->Clone();\r
 980   etaRecKc->Divide(etaRecK,etaAllK,1,1,"B");\r
 981   etaRecKc->SetName("etaRecEffK");\r
 982 \r
 983   etaRecKc->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle());\r
 984   etaRecKc->GetYaxis()->SetTitle("efficiency");\r
 985   sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffHisto->GetAxis(0)->GetTitle());\r
 986   etaRecKc->SetTitle(title);\r
 987 \r
 988 \r
 989   aFolderObj->Add(etaRecKc);\r
 990 \r
 991   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
 992   fEffHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons\r
 993   TH1D *etaAllP = fEffHisto->Projection(0);\r
 994 \r
 995   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
 996   TH1D *etaRecP = fEffHisto->Projection(0);\r
 997   TH1D *etaRecPc = (TH1D*)etaRecP->Clone();\r
 998   etaRecPc->Divide(etaRecP,etaAllP,1,1,"B");\r
 999   etaRecPc->SetName("etaRecEffP");\r
1000 \r
1001   etaRecPc->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle());\r
1002   etaRecPc->GetYaxis()->SetTitle("efficiency");\r
1003   sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffHisto->GetAxis(0)->GetTitle());\r
1004   etaRecPc->SetTitle(title);\r
1005 \r
1006   aFolderObj->Add(etaRecPc);\r
1007 \r
1008   // findable efficiency vs eta\r
1009 \r
1010   fEffHisto->GetAxis(3)->SetRangeUser(0.,4.); \r
1011   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1012   fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable\r
1013   TH1D *etaAllF = fEffHisto->Projection(0);\r
1014 \r
1015   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.);\r
1016   fEffHisto->GetAxis(5)->SetRangeUser(1.,1.);\r
1017 \r
1018   TH1D *etaRecF = fEffHisto->Projection(0); // rec findable\r
1019   TH1D *etaRecFc = (TH1D*)etaRecF->Clone();\r
1020   etaRecFc->Divide(etaRecF,etaAllF,1,1,"B");\r
1021   etaRecFc->SetName("etaRecEffF");\r
1022 \r
1023   etaRecFc->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle());\r
1024   etaRecFc->GetYaxis()->SetTitle("efficiency");\r
1025   sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffHisto->GetAxis(0)->GetTitle());\r
1026   etaRecFc->SetTitle(title);\r
1027 \r
1028   aFolderObj->Add(etaRecFc);\r
1029 \r
1030   //\r
1031   // efficiency vs phi\r
1032   //\r
1033 \r
1034   fEffHisto->GetAxis(0)->SetRangeUser(-0.9,0.9); // eta range\r
1035   fEffHisto->GetAxis(2)->SetRangeUser(0.2,10.); // pt range\r
1036   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.);   // all\r
1037   fEffHisto->GetAxis(5)->SetRangeUser(0.,1.);   // all\r
1038 \r
1039   TH1D *phiAll = fEffHisto->Projection(1);\r
1040 \r
1041   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.);  // reconstructed \r
1042   TH1D *phiRec = fEffHisto->Projection(1);\r
1043   TH1D *phiRecc = (TH1D*)phiRec->Clone();\r
1044   phiRecc->Divide(phiRec,phiAll,1,1,"B");\r
1045   phiRecc->SetName("phiRecEff");\r
1046 \r
1047   phiRecc->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle());\r
1048   phiRecc->GetYaxis()->SetTitle("efficiency");\r
1049   sprintf(title,"%s vs %s","rec. efficiency",fEffHisto->GetAxis(1)->GetTitle());\r
1050   phiRecc->SetTitle(title);\r
1051 \r
1052   aFolderObj->Add(phiRecc);\r
1053 \r
1054   // rec efficiency vs pid vs phi\r
1055   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1056   fEffHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions\r
1057 \r
1058   TH1D *phiAllPi = fEffHisto->Projection(1);\r
1059 \r
1060   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1061   TH1D *phiRecPi = fEffHisto->Projection(1);\r
1062   TH1D *phiRecPic = (TH1D*)phiRecPi->Clone();\r
1063   phiRecPic->Divide(phiRecPi,phiAllPi,1,1,"B");\r
1064   phiRecPic->SetName("phiRecEffPi");\r
1065 \r
1066   phiRecPic->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle());\r
1067   phiRecPic->GetYaxis()->SetTitle("efficiency");\r
1068   sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffHisto->GetAxis(1)->GetTitle());\r
1069   phiRecPic->SetTitle(title);\r
1070 \r
1071   aFolderObj->Add(phiRecPic);\r
1072 \r
1073   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1074   fEffHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons\r
1075   TH1D *phiAllK = fEffHisto->Projection(1);\r
1076 \r
1077   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1078   TH1D *phiRecK = fEffHisto->Projection(1);\r
1079 \r
1080   TH1D *phiRecKc = (TH1D*)phiRecK->Clone();\r
1081   phiRecKc->Divide(phiRecK,phiAllK,1,1,"B");\r
1082   phiRecKc->SetName("phiRecEffK");\r
1083 \r
1084   phiRecKc->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle());\r
1085   phiRecKc->GetYaxis()->SetTitle("efficiency");\r
1086   sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffHisto->GetAxis(1)->GetTitle());\r
1087   phiRecKc->SetTitle(title);\r
1088 \r
1089 \r
1090   aFolderObj->Add(phiRecKc);\r
1091 \r
1092   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1093   fEffHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons\r
1094   TH1D *phiAllP = fEffHisto->Projection(1);\r
1095 \r
1096   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1097   TH1D *phiRecP = fEffHisto->Projection(1);\r
1098   TH1D *phiRecPc = (TH1D*)phiRecP->Clone();\r
1099   phiRecPc->Divide(phiRecP,phiAllP,1,1,"B");\r
1100   phiRecPc->SetName("phiRecEffP");\r
1101 \r
1102   phiRecPc->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle());\r
1103   phiRecPc->GetYaxis()->SetTitle("efficiency");\r
1104   sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffHisto->GetAxis(1)->GetTitle());\r
1105   phiRecPc->SetTitle(title);\r
1106 \r
1107   aFolderObj->Add(phiRecPc);\r
1108 \r
1109   // findable efficiency vs phi\r
1110 \r
1111   fEffHisto->GetAxis(3)->SetRangeUser(0.,4.); \r
1112   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1113   fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable\r
1114   TH1D *phiAllF = fEffHisto->Projection(1);\r
1115 \r
1116   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.);\r
1117   fEffHisto->GetAxis(5)->SetRangeUser(1.,1.);\r
1118 \r
1119   TH1D *phiRecF = fEffHisto->Projection(1); // rec findable\r
1120   TH1D *phiRecFc = (TH1D*)phiRecF->Clone();\r
1121   phiRecFc->Divide(phiRecF,phiAllF,1,1,"B");\r
1122   phiRecFc->SetName("phiRecEffF");\r
1123 \r
1124   phiRecFc->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle());\r
1125   phiRecFc->GetYaxis()->SetTitle("efficiency");\r
1126   sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffHisto->GetAxis(1)->GetTitle());\r
1127   phiRecFc->SetTitle(title);\r
1128 \r
1129   aFolderObj->Add(phiRecFc);\r
1130   }\r
1131   else {\r
1132   // \r
1133   Float_t minEta=-1.5, maxEta=1.5;\r
1134   Float_t minR=0.0, maxR=150.0;\r
1135   Float_t minPt=0.15, maxPt=100.0;\r
1136 \r
1137   // mother eta range\r
1138   fEffSecHisto->GetAxis(8)->SetRangeUser(minEta,maxEta);\r
1139 \r
1140   // particle creation radius range \r
1141   fEffSecHisto->GetAxis(6)->SetRangeUser(minR,maxR);\r
1142 \r
1143   //\r
1144   fEffSecHisto->GetAxis(0)->SetRangeUser(minEta,maxEta);\r
1145   fEffSecHisto->GetAxis(2)->SetRangeUser(minPt,maxPt);\r
1146 \r
1147   // rec efficiency vs pt\r
1148   TH1D *ptAll = fEffSecHisto->Projection(2);\r
1149 \r
1150   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.);  // reconstructed \r
1151   TH1D *ptRec = fEffSecHisto->Projection(2);\r
1152   TH1D *ptRecc = (TH1D*)ptRec->Clone();\r
1153   ptRecc->Divide(ptRec,ptAll,1,1,"B");\r
1154   ptRecc->SetName("ptRecEff");\r
1155 \r
1156   ptRecc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(2)->GetTitle());\r
1157   ptRecc->GetYaxis()->SetTitle("efficiency");\r
1158   sprintf(title,"%s vs %s","rec. efficiency",fEffSecHisto->GetAxis(2)->GetTitle());\r
1159   ptRecc->SetTitle(title);\r
1160 \r
1161   ptRecc->SetBit(TH1::kLogX);\r
1162   aFolderObj->Add(ptRecc);\r
1163 \r
1164   // rec efficiency vs pid vs pt\r
1165   \r
1166   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1167   fEffSecHisto->GetAxis(3)->SetRangeUser(0.,0.); // electrons\r
1168 \r
1169   TH1D *ptAllEle = fEffSecHisto->Projection(2);\r
1170 \r
1171   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1172   TH1D *ptRecEle = fEffSecHisto->Projection(2);\r
1173   TH1D *ptRecElec = (TH1D*)ptRecEle->Clone();\r
1174   ptRecElec->Divide(ptRecEle,ptAllEle,1,1,"B");\r
1175   ptRecElec->SetName("ptRecEffEle");\r
1176 \r
1177   ptRecElec->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(2)->GetTitle());\r
1178   ptRecElec->GetYaxis()->SetTitle("efficiency");\r
1179   sprintf(title,"%s vs %s","rec. efficiency (electrons)",fEffSecHisto->GetAxis(2)->GetTitle());\r
1180   ptRecElec->SetTitle(title);\r
1181 \r
1182   ptRecElec->SetBit(TH1::kLogX);\r
1183   aFolderObj->Add(ptRecElec);\r
1184 \r
1185   //\r
1186 \r
1187   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1188   fEffSecHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions\r
1189 \r
1190   TH1D *ptAllPi = fEffSecHisto->Projection(2);\r
1191 \r
1192   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1193   TH1D *ptRecPi = fEffSecHisto->Projection(2);\r
1194   TH1D *ptRecPic = (TH1D*)ptRecPi->Clone();\r
1195   ptRecPic->Divide(ptRecPi,ptAllPi,1,1,"B");\r
1196   ptRecPic->SetName("ptRecEffPi");\r
1197 \r
1198   ptRecPic->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(2)->GetTitle());\r
1199   ptRecPic->GetYaxis()->SetTitle("efficiency");\r
1200   sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffSecHisto->GetAxis(2)->GetTitle());\r
1201   ptRecPic->SetTitle(title);\r
1202 \r
1203   ptRecPic->SetBit(TH1::kLogX);\r
1204   aFolderObj->Add(ptRecPic);\r
1205 \r
1206   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1207   fEffSecHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons\r
1208   TH1D *ptAllK = fEffSecHisto->Projection(2);\r
1209 \r
1210   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1211   TH1D *ptRecK = fEffSecHisto->Projection(2);\r
1212 \r
1213   TH1D *ptRecKc = (TH1D*)ptRecK->Clone();\r
1214   ptRecKc->Divide(ptRecK,ptAllK,1,1,"B");\r
1215   ptRecKc->SetName("ptRecEffK");\r
1216 \r
1217   ptRecKc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(2)->GetTitle());\r
1218   ptRecKc->GetYaxis()->SetTitle("efficiency");\r
1219   sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffSecHisto->GetAxis(2)->GetTitle());\r
1220   ptRecKc->SetTitle(title);\r
1221 \r
1222 \r
1223   ptRecKc->SetBit(TH1::kLogX);\r
1224   aFolderObj->Add(ptRecKc);\r
1225 \r
1226   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1227   fEffSecHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons\r
1228   TH1D *ptAllP = fEffSecHisto->Projection(2);\r
1229 \r
1230   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1231   TH1D *ptRecP = fEffSecHisto->Projection(2);\r
1232   TH1D *ptRecPc = (TH1D*)ptRecP->Clone();\r
1233   ptRecPc->Divide(ptRecP,ptAllP,1,1,"B");\r
1234   ptRecPc->SetName("ptRecEffP");\r
1235 \r
1236   ptRecPc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(2)->GetTitle());\r
1237   ptRecPc->GetYaxis()->SetTitle("efficiency");\r
1238   sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffSecHisto->GetAxis(2)->GetTitle());\r
1239   ptRecPc->SetTitle(title);\r
1240 \r
1241   ptRecPc->SetBit(TH1::kLogX);\r
1242   aFolderObj->Add(ptRecPc);\r
1243 \r
1244   // findable efficiency vs pt\r
1245 \r
1246   fEffSecHisto->GetAxis(3)->SetRangeUser(0.,4.); \r
1247   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1248   fEffSecHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable\r
1249   TH1D *ptAllF = fEffSecHisto->Projection(2);\r
1250 \r
1251   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.);\r
1252   fEffSecHisto->GetAxis(5)->SetRangeUser(1.,1.);\r
1253 \r
1254   TH1D *ptRecF = fEffSecHisto->Projection(2); // rec findable\r
1255   TH1D *ptRecFc = (TH1D*)ptRecF->Clone();\r
1256   ptRecFc->Divide(ptRecF,ptAllF,1,1,"B");\r
1257   ptRecFc->SetName("ptRecEffF");\r
1258 \r
1259   ptRecFc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(2)->GetTitle());\r
1260   ptRecFc->GetYaxis()->SetTitle("efficiency");\r
1261   sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffSecHisto->GetAxis(2)->GetTitle());\r
1262   ptRecFc->SetTitle(title);\r
1263 \r
1264   ptRecFc->SetBit(TH1::kLogX);\r
1265   aFolderObj->Add(ptRecFc);\r
1266 \r
1267   //\r
1268   // efficiency vs eta\r
1269   //\r
1270   fEffSecHisto->GetAxis(2)->SetRangeUser(minPt,maxPt);\r
1271   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.);   // all\r
1272   fEffSecHisto->GetAxis(5)->SetRangeUser(0.,1.);   // all\r
1273 \r
1274   TH1D *etaAll = fEffSecHisto->Projection(0);\r
1275 \r
1276   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.);  // reconstructed \r
1277   TH1D *etaRec = fEffSecHisto->Projection(0);\r
1278   TH1D *etaRecc = (TH1D*)etaRec->Clone();\r
1279   etaRecc->Divide(etaRec,etaAll,1,1,"B");\r
1280   etaRecc->SetName("etaRecEff");\r
1281 \r
1282   etaRecc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(0)->GetTitle());\r
1283   etaRecc->GetYaxis()->SetTitle("efficiency");\r
1284   sprintf(title,"%s vs %s","rec. efficiency",fEffSecHisto->GetAxis(0)->GetTitle());\r
1285   etaRecc->SetTitle(title);\r
1286 \r
1287   aFolderObj->Add(etaRecc);\r
1288 \r
1289   // rec efficiency vs pid vs eta\r
1290   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1291   fEffSecHisto->GetAxis(3)->SetRangeUser(0.,0.); // electrons\r
1292 \r
1293   TH1D *etaAllEle = fEffSecHisto->Projection(0);\r
1294 \r
1295   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1296   TH1D *etaRecEle = fEffSecHisto->Projection(0);\r
1297   TH1D *etaRecElec = (TH1D*)etaRecEle->Clone();\r
1298   etaRecElec->Divide(etaRecEle,etaAllEle,1,1,"B");\r
1299   etaRecElec->SetName("etaRecEffEle");\r
1300 \r
1301   etaRecElec->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(0)->GetTitle());\r
1302   etaRecElec->GetYaxis()->SetTitle("efficiency");\r
1303   sprintf(title,"%s vs %s","rec. efficiency (electrons)",fEffSecHisto->GetAxis(0)->GetTitle());\r
1304   etaRecElec->SetTitle(title);\r
1305 \r
1306   aFolderObj->Add(etaRecElec);\r
1307 \r
1308   //\r
1309   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1310   fEffSecHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions\r
1311 \r
1312   TH1D *etaAllPi = fEffSecHisto->Projection(0);\r
1313 \r
1314   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1315   TH1D *etaRecPi = fEffSecHisto->Projection(0);\r
1316   TH1D *etaRecPic = (TH1D*)etaRecPi->Clone();\r
1317   etaRecPic->Divide(etaRecPi,etaAllPi,1,1,"B");\r
1318   etaRecPic->SetName("etaRecEffPi");\r
1319 \r
1320   etaRecPic->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(0)->GetTitle());\r
1321   etaRecPic->GetYaxis()->SetTitle("efficiency");\r
1322   sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffSecHisto->GetAxis(0)->GetTitle());\r
1323   etaRecPic->SetTitle(title);\r
1324 \r
1325   aFolderObj->Add(etaRecPic);\r
1326 \r
1327   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1328   fEffSecHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons\r
1329   TH1D *etaAllK = fEffSecHisto->Projection(0);\r
1330 \r
1331   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1332   TH1D *etaRecK = fEffSecHisto->Projection(0);\r
1333 \r
1334   TH1D *etaRecKc = (TH1D*)etaRecK->Clone();\r
1335   etaRecKc->Divide(etaRecK,etaAllK,1,1,"B");\r
1336   etaRecKc->SetName("etaRecEffK");\r
1337 \r
1338   etaRecKc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(0)->GetTitle());\r
1339   etaRecKc->GetYaxis()->SetTitle("efficiency");\r
1340   sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffSecHisto->GetAxis(0)->GetTitle());\r
1341   etaRecKc->SetTitle(title);\r
1342 \r
1343 \r
1344   aFolderObj->Add(etaRecKc);\r
1345 \r
1346   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1347   fEffSecHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons\r
1348   TH1D *etaAllP = fEffSecHisto->Projection(0);\r
1349 \r
1350   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1351   TH1D *etaRecP = fEffSecHisto->Projection(0);\r
1352   TH1D *etaRecPc = (TH1D*)etaRecP->Clone();\r
1353   etaRecPc->Divide(etaRecP,etaAllP,1,1,"B");\r
1354   etaRecPc->SetName("etaRecEffP");\r
1355 \r
1356   etaRecPc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(0)->GetTitle());\r
1357   etaRecPc->GetYaxis()->SetTitle("efficiency");\r
1358   sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffSecHisto->GetAxis(0)->GetTitle());\r
1359   etaRecPc->SetTitle(title);\r
1360 \r
1361   aFolderObj->Add(etaRecPc);\r
1362 \r
1363   // findable efficiency vs eta\r
1364 \r
1365   fEffSecHisto->GetAxis(3)->SetRangeUser(0.,4.); \r
1366   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1367   fEffSecHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable\r
1368   TH1D *etaAllF = fEffSecHisto->Projection(0);\r
1369 \r
1370   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.);\r
1371   fEffSecHisto->GetAxis(5)->SetRangeUser(1.,1.);\r
1372 \r
1373   TH1D *etaRecF = fEffSecHisto->Projection(0); // rec findable\r
1374   TH1D *etaRecFc = (TH1D*)etaRecF->Clone();\r
1375   etaRecFc->Divide(etaRecF,etaAllF,1,1,"B");\r
1376   etaRecFc->SetName("etaRecEffF");\r
1377 \r
1378   etaRecFc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(0)->GetTitle());\r
1379   etaRecFc->GetYaxis()->SetTitle("efficiency");\r
1380   sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffSecHisto->GetAxis(0)->GetTitle());\r
1381   etaRecFc->SetTitle(title);\r
1382 \r
1383   aFolderObj->Add(etaRecFc);\r
1384 \r
1385   //\r
1386   // efficiency vs phi\r
1387   //\r
1388 \r
1389   fEffSecHisto->GetAxis(0)->SetRangeUser(minEta,maxEta);\r
1390   fEffSecHisto->GetAxis(2)->SetRangeUser(minPt,maxPt);\r
1391 \r
1392   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.);   // all\r
1393   fEffSecHisto->GetAxis(5)->SetRangeUser(0.,1.);   // all\r
1394 \r
1395   TH1D *phiAll = fEffSecHisto->Projection(1);\r
1396 \r
1397   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.);  // reconstructed \r
1398   TH1D *phiRec = fEffSecHisto->Projection(1);\r
1399   TH1D *phiRecc = (TH1D*)phiRec->Clone();\r
1400   phiRecc->Divide(phiRec,phiAll,1,1,"B");\r
1401   phiRecc->SetName("phiRecEff");\r
1402 \r
1403   phiRecc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(1)->GetTitle());\r
1404   phiRecc->GetYaxis()->SetTitle("efficiency");\r
1405   sprintf(title,"%s vs %s","rec. efficiency",fEffSecHisto->GetAxis(1)->GetTitle());\r
1406   phiRecc->SetTitle(title);\r
1407 \r
1408   aFolderObj->Add(phiRecc);\r
1409 \r
1410   // rec efficiency vs pid vs phi\r
1411   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1412   fEffSecHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions\r
1413 \r
1414   TH1D *phiAllEle = fEffSecHisto->Projection(1);\r
1415 \r
1416   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1417   TH1D *phiRecEle = fEffSecHisto->Projection(1);\r
1418   TH1D *phiRecElec = (TH1D*)phiRecEle->Clone();\r
1419   phiRecElec->Divide(phiRecEle,phiAllEle,1,1,"B");\r
1420   phiRecElec->SetName("phiRecEffEle");\r
1421 \r
1422   phiRecElec->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(1)->GetTitle());\r
1423   phiRecElec->GetYaxis()->SetTitle("efficiency");\r
1424   sprintf(title,"%s vs %s","rec. efficiency (electrons)",fEffSecHisto->GetAxis(1)->GetTitle());\r
1425   phiRecElec->SetTitle(title);\r
1426 \r
1427   aFolderObj->Add(phiRecElec);\r
1428 \r
1429   //\r
1430   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1431   fEffSecHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions\r
1432 \r
1433   TH1D *phiAllPi = fEffSecHisto->Projection(1);\r
1434 \r
1435   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1436   TH1D *phiRecPi = fEffSecHisto->Projection(1);\r
1437   TH1D *phiRecPic = (TH1D*)phiRecPi->Clone();\r
1438   phiRecPic->Divide(phiRecPi,phiAllPi,1,1,"B");\r
1439   phiRecPic->SetName("phiRecEffPi");\r
1440 \r
1441   phiRecPic->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(1)->GetTitle());\r
1442   phiRecPic->GetYaxis()->SetTitle("efficiency");\r
1443   sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffSecHisto->GetAxis(1)->GetTitle());\r
1444   phiRecPic->SetTitle(title);\r
1445 \r
1446   aFolderObj->Add(phiRecPic);\r
1447 \r
1448   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1449   fEffSecHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons\r
1450   TH1D *phiAllK = fEffSecHisto->Projection(1);\r
1451 \r
1452   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1453   TH1D *phiRecK = fEffSecHisto->Projection(1);\r
1454 \r
1455   TH1D *phiRecKc = (TH1D*)phiRecK->Clone();\r
1456   phiRecKc->Divide(phiRecK,phiAllK,1,1,"B");\r
1457   phiRecKc->SetName("phiRecEffK");\r
1458 \r
1459   phiRecKc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(1)->GetTitle());\r
1460   phiRecKc->GetYaxis()->SetTitle("efficiency");\r
1461   sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffSecHisto->GetAxis(1)->GetTitle());\r
1462   phiRecKc->SetTitle(title);\r
1463 \r
1464 \r
1465   aFolderObj->Add(phiRecKc);\r
1466 \r
1467   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1468   fEffSecHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons\r
1469   TH1D *phiAllP = fEffSecHisto->Projection(1);\r
1470 \r
1471   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1472   TH1D *phiRecP = fEffSecHisto->Projection(1);\r
1473   TH1D *phiRecPc = (TH1D*)phiRecP->Clone();\r
1474   phiRecPc->Divide(phiRecP,phiAllP,1,1,"B");\r
1475   phiRecPc->SetName("phiRecEffP");\r
1476 \r
1477   phiRecPc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(1)->GetTitle());\r
1478   phiRecPc->GetYaxis()->SetTitle("efficiency");\r
1479   sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffSecHisto->GetAxis(1)->GetTitle());\r
1480   phiRecPc->SetTitle(title);\r
1481 \r
1482   aFolderObj->Add(phiRecPc);\r
1483 \r
1484   // findable efficiency vs phi\r
1485 \r
1486   fEffSecHisto->GetAxis(3)->SetRangeUser(0.,4.); \r
1487   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1488   fEffSecHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable\r
1489   TH1D *phiAllF = fEffSecHisto->Projection(1);\r
1490 \r
1491   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.);\r
1492   fEffSecHisto->GetAxis(5)->SetRangeUser(1.,1.);\r
1493 \r
1494   TH1D *phiRecF = fEffSecHisto->Projection(1); // rec findable\r
1495   TH1D *phiRecFc = (TH1D*)phiRecF->Clone();\r
1496   phiRecFc->Divide(phiRecF,phiAllF,1,1,"B");\r
1497   phiRecFc->SetName("phiRecEffF");\r
1498 \r
1499   phiRecFc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(1)->GetTitle());\r
1500   phiRecFc->GetYaxis()->SetTitle("efficiency");\r
1501   sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffSecHisto->GetAxis(1)->GetTitle());\r
1502   phiRecFc->SetTitle(title);\r
1503 \r
1504   aFolderObj->Add(phiRecFc);\r
1505   }\r
1506 \r
1507   // export objects to analysis folder\r
1508   fAnalysisFolder = ExportToFolder(aFolderObj);\r
1509 \r
1510   // delete only TObjArray\r
1511   if(aFolderObj) delete aFolderObj;\r
1512 }\r
1513 \r
1514 //_____________________________________________________________________________\r
1515 TFolder* AliPerformanceEff::ExportToFolder(TObjArray * array) \r
1516 {\r
1517   // recreate folder avery time and export objects to new one\r
1518   //\r
1519   AliPerformanceEff * comp=this;\r
1520   TFolder *folder = comp->GetAnalysisFolder();\r
1521 \r
1522   TString name, title;\r
1523   TFolder *newFolder = 0;\r
1524   Int_t i = 0;\r
1525   Int_t size = array->GetSize();\r
1526 \r
1527   if(folder) { \r
1528      // get name and title from old folder\r
1529      name = folder->GetName();  \r
1530      title = folder->GetTitle();  \r
1531 \r
1532          // delete old one\r
1533      delete folder;\r
1534 \r
1535          // create new one\r
1536      newFolder = CreateFolder(name.Data(),title.Data());\r
1537      newFolder->SetOwner();\r
1538 \r
1539          // add objects to folder\r
1540      while(i < size) {\r
1541            newFolder->Add(array->At(i));\r
1542            i++;\r
1543          }\r
1544   }\r
1545 \r
1546 return newFolder;\r
1547 }\r
1548 \r
1549 \r
1550 //_____________________________________________________________________________\r
1551 TFolder* AliPerformanceEff::CreateFolder(TString name,TString title) { \r
1552 // create folder for analysed histograms\r
1553 //\r
1554 TFolder *folder = 0;\r
1555   folder = new TFolder(name.Data(),title.Data());\r
1556 \r
1557   return folder;\r
1558 }\r