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