PWG1/TRD/AliTRDcheckPID.cxx

   1 //////////////////////////////////////////////////////
   2 //
   3 // PID performance checker of the TRD
   4 //
   5 // Performs checks of ESD information for TRD-PID and recalculate PID based on OCDB information
   6 // Also provides performance plots on detector based on the PID information - for the moment only
   7 // MC source is used but V0 is also possible. Here is a list of detector performance checks
   8 //   - Integrated dE/dx per chamber
   9 //   - <PH> as function of time bin and local radial position
  10 //   - number of clusters/tracklet
  11 //   - number of tracklets/track
  12 //
  13 // Author : Alex Wilk <wilka@uni-muenster.de>
  14 //          Alex Bercuci <A.Bercuci@gsi.de>
  15 //          Markus Fasel <M.Fasel@gsi.de>
  16 //
  17 ///////////////////////////////////////////////////////
  18
  19 #include "TAxis.h"
  20 #include "TROOT.h"
  21 #include "TPDGCode.h"
  22 #include "TCanvas.h"
  23 #include "TF1.h"
  24 #include "TH1F.h"
  25 #include "TH1D.h"
  26 #include "TH2F.h"
  27 #include "TProfile.h"
  28 #include "TProfile2D.h"
  29 #include "TGraph.h"
  30 #include "TGraphErrors.h"
  31 #include "TLegend.h"
  32
  33 #include <TClonesArray.h>
  34 #include <TObjArray.h>
  35 #include <TList.h>
  36
  37 #include "AliESDEvent.h"
  38 #include "AliESDInputHandler.h"
  39 #include "AliTrackReference.h"
  40
  41 #include "AliAnalysisTask.h"
  42
  43 #include "AliTRDtrackerV1.h"
  44 #include "AliTRDtrackV1.h"
  45 #include "AliTRDcluster.h"
  46 #include "AliTRDReconstructor.h"
  47 #include "AliCDBManager.h"
  48 #include "AliTRDpidUtil.h"
  49
  50 #include "Cal/AliTRDCalPID.h"
  51 #include "Cal/AliTRDCalPIDNN.h"
  52 #include "AliTRDcheckPID.h"
  53 #include "AliTRDinfoGen.h"
  54 #include "info/AliTRDtrackInfo.h"
  55 #include "info/AliTRDpidInfo.h"
  56 #include "info/AliTRDv0Info.h"
  57
  58 Char_t const * AliTRDcheckPID::fgMethod[3] = {"LQ", "NN", "ESD"};
  59
  60 ClassImp(AliTRDcheckPID)
  61
  62 //________________________________________________________________________
  63 AliTRDcheckPID::AliTRDcheckPID()
  64   :AliTRDrecoTask()
  65   ,fUtil(NULL)
  66   ,fGraph(NULL)
  67   ,fPID(NULL)
  68   ,fV0s(NULL)
  69   ,fMomentumAxis(NULL)
  70   ,fMinNTracklets(AliTRDgeometry::kNlayer)
  71   ,fMaxNTracklets(AliTRDgeometry::kNlayer)
  72  {
  73   //
  74   // Default constructor
  75   //
  76   SetNameTitle("TRDcheckPID", "Check TRD PID");
  77   LocalInit();
  78 }
  79
  80 //________________________________________________________________________
  81 AliTRDcheckPID::AliTRDcheckPID(char* name )
  82   :AliTRDrecoTask(name, "Check TRD PID")
  83   ,fUtil(NULL)
  84   ,fGraph(NULL)
  85   ,fPID(NULL)
  86   ,fV0s(NULL)
  87   ,fMomentumAxis(NULL)
  88   ,fMinNTracklets(AliTRDgeometry::kNlayer)
  89   ,fMaxNTracklets(AliTRDgeometry::kNlayer)
  90  {
  91   //
  92   // Default constructor
  93   //
  94
  95   LocalInit();
  96   InitFunctorList();
  97
  98   DefineInput(3, TObjArray::Class());  // v0 list
  99   DefineOutput(2, TObjArray::Class()); // pid info list
 100 }
 101
 102
 103 //________________________________________________________________________
 104 void AliTRDcheckPID::LocalInit()
 105 {
 106 // Initialize working data
 107
 108   // Initialize momentum axis with default values
 109   Double_t defaultMomenta[AliTRDCalPID::kNMom+1];
 110   for(Int_t imom = 0; imom < AliTRDCalPID::kNMom+1; imom++)
 111     defaultMomenta[imom] = AliTRDCalPID::GetMomentumBinning(imom);
 112   SetMomentumBinning(AliTRDCalPID::kNMom, defaultMomenta);
 113
 114   memset(fEfficiency, 0, AliPID::kSPECIES*sizeof(TObjArray*));
 115
 116   fUtil = new AliTRDpidUtil();
 117 }
 118
 119 //________________________________________________________________________
 120 AliTRDcheckPID::~AliTRDcheckPID()
 121 {
 122   if(fPID){fPID->Delete(); delete fPID;}
 123   if(fGraph){fGraph->Delete(); delete fGraph;}
 124   if(fUtil) delete fUtil;
 125 }
 126
 127
 128 //________________________________________________________________________
 129 void AliTRDcheckPID::UserCreateOutputObjects()
 130 {
 131   // Create histograms
 132   // Called once
 133
 134   AliTRDrecoTask::UserCreateOutputObjects();
 135   fPID = new TObjArray();
 136   fPID->SetOwner(kTRUE);
 137   PostData(2, fPID);
 138 }
 139
 140 //________________________________________________________
 141 void AliTRDcheckPID::UserExec(Option_t *opt)
 142 {
 143   //
 144   // Execution part
 145   //
 146
 147   fV0s = dynamic_cast<TObjArray *>(GetInputData(3));
 148   fPID->Delete();
 149
 150   AliTRDrecoTask::UserExec(opt);
 151 }
 152
 153
 154 //_______________________________________________________
 155 TObjArray * AliTRDcheckPID::Histos(){
 156
 157   //
 158   // Create QA histograms
 159   //
 160   if(fContainer) return fContainer;
 161
 162   Int_t xBins = AliPID::kSPECIES*fMomentumAxis->GetNbins();
 163   fContainer = new TObjArray(); fContainer->Expand(kNPlots);
 164
 165   const Float_t epsilon = 1./(2*(AliTRDpidUtil::kBins-1));     // get nice histos with bin center at 0 and 1
 166   TH1 *h = NULL;
 167
 168   const Int_t kNmethodsPID=Int_t(sizeof(fgMethod)/sizeof(Char_t*));
 169   // histos with posterior probabilities for all particle species
 170   for(Int_t is=AliPID::kSPECIES; is--;){
 171     fEfficiency[is] = new TObjArray(kNmethodsPID);
 172     fEfficiency[is]->SetOwner();
 173     fEfficiency[is]->SetName(Form("Eff_%s", AliPID::ParticleShortName(is)));
 174     fContainer->AddAt(fEfficiency[is], is?kEfficiencyMu+is-1:kEfficiency);
 175     for(Int_t im=kNmethodsPID; im--;){
 176       if(!(h = (TH2F*)gROOT->FindObject(Form("PID_%s_%s", fgMethod[im], AliPID::ParticleShortName(is))))) {
 177         h = new TH2F(Form("PID_%s_%s", fgMethod[im], AliPID::ParticleShortName(is)), "", xBins, -0.5, xBins - 0.5,
 178           AliTRDpidUtil::kBins, 0.-epsilon, 1.+epsilon);
 179       } else h->Reset();
 180       fEfficiency[is]->AddAt(h, im);
 181     }
 182   }
 183
 184   // histos of the dE/dx distribution for all 5 particle species and 11 momenta
 185   if(!(h = (TH2F*)gROOT->FindObject("dEdx"))){
 186     h = new TH2F("dEdx", "",
 187       xBins, -0.5, xBins - 0.5,
 188       200, 0, 15);
 189 //       200, 0, 10000);
 190   } else h->Reset();
 191   fContainer->AddAt(h, kdEdx);
 192
 193   // histos of the dE/dx slices for all 5 particle species and 11 momenta
 194   if(!(h = (TH2F*)gROOT->FindObject("dEdxSlice"))){
 195     h = new TH2F("dEdxSlice", "",
 196       xBins*AliTRDpidUtil::kLQslices, -0.5, xBins*AliTRDpidUtil::kLQslices - 0.5,
 197       200, 0, 5000);
 198   } else h->Reset();
 199   fContainer->AddAt(h, kdEdxSlice);
 200
 201   // histos of the pulse height distribution for all 5 particle species and 11 momenta
 202   TObjArray *fPH = new TObjArray(2);
 203   fPH->SetOwner(); fPH->SetName("PH");
 204   fContainer->AddAt(fPH, kPH);
 205   if(!(h = (TProfile2D*)gROOT->FindObject("PHT"))){
 206     h = new TProfile2D("PHT", "<PH>(tb);p*species;tb [100*ns];entries",
 207       xBins, -0.5, xBins - 0.5,
 208       AliTRDseedV1::kNtb, -0.5, AliTRDseedV1::kNtb - 0.5);
 209   } else h->Reset();
 210   fPH->AddAt(h, 0);
 211   if(!(h = (TProfile2D*)gROOT->FindObject("PHX"))){
 212     h = new TProfile2D("PHX", "<PH>(x);p*species;x_{drift} [cm];entries",
 213       xBins, -0.5, xBins - 0.5,
 214       40, 0., 4.5);
 215   } else h->Reset();
 216   fPH->AddAt(h, 1);
 217
 218   // histos of the number of clusters distribution for all 5 particle species and 11 momenta
 219   if(!(h = (TH2F*)gROOT->FindObject("NClus"))){
 220     h = new TH2F("NClus", "",
 221       xBins, -0.5, xBins - 0.5,
 222       50, -0.5, 49.5);
 223   } else h->Reset();
 224   fContainer->AddAt(h, kNClus);
 225
 226
 227   // momentum distributions - absolute and in momentum bins
 228   if(!(h = (TH1F*)gROOT->FindObject("hMom"))){
 229     h = new TH1F("hMom", "momentum distribution", fMomentumAxis->GetNbins(), fMomentumAxis->GetXmin(), fMomentumAxis->GetXmax());
 230   } else h->Reset();
 231   fContainer->AddAt(h, kMomentum);
 232
 233   if(!(h = (TH1F*)gROOT->FindObject("hMomBin"))){
 234     h = new TH1F("hMomBin", "momentum distribution in momentum bins", fMomentumAxis->GetNbins(), fMomentumAxis->GetXmin(), fMomentumAxis->GetXmax());
 235   } else h->Reset();
 236   fContainer->AddAt(h, kMomentumBin);
 237
 238   // Number of tracklets per track
 239   if(!(h = (TH2F*)gROOT->FindObject("nTracklets"))){
 240     h = new TH2F("nTracklets", "",
 241       xBins, -0.5, xBins - 0.5,
 242       AliTRDgeometry::kNlayer, 0.5, AliTRDgeometry::kNlayer+.5);
 243   } else h->Reset();
 244   fContainer->AddAt(h, kNTracklets);
 245
 246   // V0 performance
 247   if(!(h = (TH1F*)gROOT->FindObject("nV0"))){
 248     h = new TH1F("nV0", "V0s/track;v0/track;entries",
 249       6, -0.5, 5.5);
 250   } else h->Reset();
 251   fContainer->AddAt(h, kV0);
 252
 253   return fContainer;
 254 }
 255
 256
 257 //________________________________________________________________________
 258 Bool_t AliTRDcheckPID::CheckTrackQuality(const AliTRDtrackV1* track) const
 259 {
 260   //
 261   // Check if the track is ok for PID
 262   //
 263
 264   Int_t ntracklets = track->GetNumberOfTracklets();
 265   if(ntracklets >= fMinNTracklets && ntracklets <= fMaxNTracklets) return 1;
 266 //   if(!fESD)
 267 //     return 0;
 268
 269   return 0;
 270 }
 271
 272 //________________________________________________________________________
 273 Int_t AliTRDcheckPID::CalcPDG(AliTRDtrackV1* track)
 274 {
 275 // Documentation to come
 276
 277   track -> SetReconstructor(AliTRDinfoGen::Reconstructor());
 278   (const_cast<AliTRDrecoParam*>(AliTRDinfoGen::Reconstructor()->GetRecoParam()))->SetPIDNeuralNetwork();
 279   track -> CookPID();
 280
 281   if(track -> GetPID(AliPID::kElectron) > track -> GetPID(AliPID::kMuon) + track -> GetPID(AliPID::kPion)  + track -> GetPID(AliPID::kKaon) + track -> GetPID(AliPID::kProton)){
 282     return kElectron;
 283   }
 284   else if(track -> GetPID(kProton) > track -> GetPID(AliPID::kPion)  && track -> GetPID(AliPID::kProton) > track -> GetPID(AliPID::kKaon)  && track -> GetPID(AliPID::kProton) > track -> GetPID(AliPID::kMuon)){
 285     return kProton;
 286   }
 287   else if(track -> GetPID(AliPID::kKaon) > track -> GetPID(AliPID::kMuon)  && track -> GetPID(AliPID::kKaon) > track -> GetPID(AliPID::kPion)){
 288     return kKPlus;
 289   }
 290   else if(track -> GetPID(AliPID::kMuon) > track -> GetPID(AliPID::kPion)){
 291     return kMuonPlus;
 292   }
 293   else{
 294     return kPiPlus;
 295   }
 296 }
 297
 298
 299 //_______________________________________________________
 300 TH1 *AliTRDcheckPID::PlotLQ(const AliTRDtrackV1 *track)
 301 {
 302   //
 303   // Plot the probabilities for electrons using 2-dim LQ
 304   //
 305
 306   if(!fkESD){
 307     AliDebug(2, "No ESD info available.");
 308     return NULL;
 309   }
 310
 311   if(track) fkTrack = track;
 312   if(!fkTrack){
 313     AliDebug(2, "No Track defined.");
 314     return NULL;
 315   }
 316
 317   ULong_t status;
 318   status = fkESD -> GetStatus();
 319   if(!(status&AliESDtrack::kTRDin)) return NULL;
 320
 321   if(!CheckTrackQuality(fkTrack)) return NULL;
 322
 323   AliTRDtrackV1 cTrack(*fkTrack);
 324   cTrack.SetReconstructor(AliTRDinfoGen::Reconstructor());
 325
 326   Int_t pdg = 0;
 327   Float_t momentum = 0.;
 328
 329   if(fkMC){
 330     if(fkMC->GetTrackRef()) momentum = fkMC->GetTrackRef()->P();
 331     pdg = fkMC->GetPDG();
 332   } else{
 333     //AliWarning("No MC info available!");
 334     momentum = cTrack.GetMomentum(0);
 335     pdg = CalcPDG(&cTrack);
 336   }
 337   if(!IsInRange(momentum)) return NULL;
 338
 339   (const_cast<AliTRDrecoParam*>(AliTRDinfoGen::Reconstructor()->GetRecoParam()))->SetPIDNeuralNetwork(kFALSE);
 340   cTrack.CookPID();
 341   if(cTrack.GetNumberOfTrackletsPID() < fMinNTracklets) return NULL;
 342   Int_t species = AliTRDpidUtil::Pdg2Pid(pdg);
 343
 344   TH2F *hPIDLQ(NULL);
 345   TObjArray *eff(NULL);
 346   for(Int_t is=AliPID::kSPECIES; is--;){
 347     if(!(eff = dynamic_cast<TObjArray *>(fContainer->At(is?kEfficiencyMu+is-1:kEfficiency)))){
 348       AliWarning("No Histogram List defined.");
 349       return NULL;
 350     }
 351     if(!(hPIDLQ = dynamic_cast<TH2F *>(eff->At(AliTRDpidUtil::kLQ)))){
 352       AliWarning("No Histogram defined.");
 353       return NULL;
 354     }
 355
 356     hPIDLQ -> Fill(FindBin(species, momentum), cTrack.GetPID(is));
 357   }
 358   return hPIDLQ;
 359 }
 360
 361
 362
 363
 364 //_______________________________________________________
 365 TH1 *AliTRDcheckPID::PlotNN(const AliTRDtrackV1 *track)
 366 {
 367   //
 368   // Plot the probabilities for electrons using 2-dim LQ
 369   //
 370
 371   if(!fkESD){
 372     AliDebug(2, "No ESD info available.");
 373     return NULL;
 374   }
 375
 376   if(track) fkTrack = track;
 377   if(!fkTrack){
 378     AliDebug(2, "No Track defined.");
 379     return NULL;
 380   }
 381
 382   ULong_t status;
 383   status = fkESD -> GetStatus();
 384   if(!(status&AliESDtrack::kTRDin)) return NULL;
 385
 386   if(!CheckTrackQuality(fkTrack)) return NULL;
 387
 388   AliTRDtrackV1 cTrack(*fkTrack);
 389   cTrack.SetReconstructor(AliTRDinfoGen::Reconstructor());
 390
 391   Int_t pdg = 0;
 392   Float_t momentum = 0.;
 393   if(fkMC){
 394     if(fkMC->GetTrackRef()) momentum = fkMC->GetTrackRef()->P();
 395     pdg = fkMC->GetPDG();
 396   } else {
 397     //AliWarning("No MC info available!");
 398     momentum = cTrack.GetMomentum(0);
 399     pdg = CalcPDG(&cTrack);
 400   }
 401   if(!IsInRange(momentum)) return NULL;
 402
 403   (const_cast<AliTRDrecoParam*>(AliTRDinfoGen::Reconstructor()->GetRecoParam()))->SetPIDNeuralNetwork();
 404   cTrack.CookPID();
 405   if(cTrack.GetNumberOfTrackletsPID() < fMinNTracklets) return NULL;
 406
 407   Int_t species = AliTRDpidUtil::Pdg2Pid(pdg);
 408
 409
 410   TH2F *hPIDNN(NULL);
 411   TObjArray *eff(NULL);
 412   for(Int_t is=AliPID::kSPECIES; is--;){
 413     if(!(eff = dynamic_cast<TObjArray *>(fContainer->At(is?kEfficiencyMu+is-1:kEfficiency)))){
 414       AliWarning("No Histogram List defined.");
 415       return NULL;
 416     }
 417     if(!(hPIDNN = dynamic_cast<TH2F *>(eff->At(AliTRDpidUtil::kNN)))){
 418       AliWarning("No Histogram defined.");
 419       return NULL;
 420     }
 421
 422     hPIDNN->Fill(FindBin(species, momentum), cTrack.GetPID(is));
 423   }
 424   return hPIDNN;
 425 }
 426
 427
 428
 429 //_______________________________________________________
 430 TH1 *AliTRDcheckPID::PlotESD(const AliTRDtrackV1 *track)
 431 {
 432   //
 433   // Plot the probabilities for electrons using 2-dim LQ
 434   //
 435
 436   if(!fkESD){
 437     AliDebug(2, "No ESD info available.");
 438     return NULL;
 439   }
 440
 441   if(track) fkTrack = track;
 442   if(!fkTrack){
 443     AliDebug(2, "No Track defined.");
 444     return NULL;
 445   }
 446
 447   ULong_t status;
 448   status = fkESD -> GetStatus();
 449   if(!(status&AliESDtrack::kTRDin)) return NULL;
 450
 451   if(!CheckTrackQuality(fkTrack)) return NULL;
 452   if(fkTrack->GetNumberOfTrackletsPID() < fMinNTracklets) return NULL;
 453
 454   Int_t pdg = 0;
 455   Float_t momentum = 0.;
 456   if(fkMC){
 457     if(fkMC->GetTrackRef()) momentum = fkMC->GetTrackRef()->P();
 458     pdg = fkMC->GetPDG();
 459   } else {
 460     //AliWarning("No MC info available!");
 461     AliTRDtrackV1 cTrack(*fkTrack);
 462     cTrack.SetReconstructor(AliTRDinfoGen::Reconstructor());
 463     momentum = cTrack.GetMomentum(0);
 464     pdg = CalcPDG(&cTrack);
 465   }
 466   if(!IsInRange(momentum)) return NULL;
 467
 468   const Double32_t *pidESD = fkESD->GetResponseIter();
 469   Int_t species = AliTRDpidUtil::Pdg2Pid(pdg);
 470
 471   TH2F *hPID(NULL);
 472   TObjArray *eff(NULL);
 473   for(Int_t is=AliPID::kSPECIES; is--;){
 474     if(!(eff = dynamic_cast<TObjArray *>(fContainer->At(is?kEfficiencyMu+is-1:kEfficiency)))){
 475       AliWarning("No Histogram List defined.");
 476       return NULL;
 477     }
 478     if(!(hPID = dynamic_cast<TH2F *>(eff->At(AliTRDpidUtil::kESD)))){
 479       AliWarning("No Histogram defined.");
 480       return NULL;
 481     }
 482
 483     hPID->Fill(FindBin(species, momentum), pidESD[is]);
 484   }
 485   return hPID;
 486 }
 487
 488
 489
 490 //_______________________________________________________
 491 TH1 *AliTRDcheckPID::PlotdEdx(const AliTRDtrackV1 *track)
 492 {
 493   //
 494   // Plot the probabilities for electrons using 2-dim LQ
 495   //
 496
 497   if(track) fkTrack = track;
 498   if(!fkTrack){
 499     AliDebug(2, "No Track defined.");
 500     return NULL;
 501   }
 502
 503   if(!CheckTrackQuality(fkTrack)) return NULL;
 504
 505   TH2F *hdEdx;
 506   if(!(hdEdx = dynamic_cast<TH2F *>(fContainer->At(kdEdx)))){
 507     AliWarning("No Histogram defined.");
 508     return NULL;
 509   }
 510
 511   AliTRDtrackV1 cTrack(*fkTrack);
 512   cTrack.SetReconstructor(AliTRDinfoGen::Reconstructor());
 513   Int_t pdg = 0;
 514   Float_t momentum = 0.;
 515   if(fkMC){
 516     if(fkMC->GetTrackRef()) momentum = fkMC->GetTrackRef()->P();
 517     pdg = fkMC->GetPDG();
 518   } else {
 519     //AliWarning("No MC info available!");
 520     momentum = cTrack.GetMomentum(0);
 521     pdg = CalcPDG(&cTrack);
 522   }
 523   if(!IsInRange(momentum)) return NULL;
 524
 525   // Init exchange container
 526   Int_t s(AliTRDpidUtil::Pdg2Pid(pdg));
 527   AliTRDpidInfo *pid = new AliTRDpidInfo(s);
 528
 529   (const_cast<AliTRDrecoParam*>(AliTRDinfoGen::Reconstructor()->GetRecoParam()))->SetPIDNeuralNetwork(kTRUE);
 530
 531   Float_t sumdEdx(0.);
 532   Int_t iBin = FindBin(s, momentum);
 533   AliTRDseedV1 *tracklet = NULL;
 534   for(Int_t ily = 0; ily < AliTRDgeometry::kNlayer; ily++){
 535     tracklet = cTrack.GetTracklet(ily);
 536     if(!tracklet) continue;
 537     tracklet -> CookdEdx(AliTRDpidUtil::kNNslices);
 538
 539     // fill exchange container
 540     pid->PushBack(tracklet->GetPlane(),
 541                   AliTRDpidUtil::GetMomentumBin(tracklet->GetMomentum()), tracklet->GetdEdx());
 542
 543     sumdEdx = 0.;
 544     for(Int_t i = AliTRDpidUtil::kNNslices; i--;) sumdEdx += tracklet->GetdEdx()[i];
 545     sumdEdx /= AliTRDCalPIDNN::kMLPscale;
 546     hdEdx -> Fill(iBin, sumdEdx);
 547   }
 548   fPID->Add(pid);
 549
 550   return hdEdx;
 551 }
 552
 553
 554 //_______________________________________________________
 555 TH1 *AliTRDcheckPID::PlotdEdxSlice(const AliTRDtrackV1 *track)
 556 {
 557   //
 558   // Plot the probabilities for electrons using 2-dim LQ
 559   //
 560
 561   if(track) fkTrack = track;
 562   if(!fkTrack){
 563     AliDebug(2, "No Track defined.");
 564     return NULL;
 565   }
 566
 567   if(!CheckTrackQuality(fkTrack)) return NULL;
 568
 569   TH2F *hdEdxSlice;
 570   if(!(hdEdxSlice = dynamic_cast<TH2F *>(fContainer->At(kdEdxSlice)))){
 571     AliWarning("No Histogram defined.");
 572     return NULL;
 573   }
 574
 575   AliTRDtrackV1 cTrack(*fkTrack);
 576   cTrack.SetReconstructor(AliTRDinfoGen::Reconstructor());
 577   Int_t pdg = 0;
 578   Float_t momentum = 0.;
 579   if(fkMC){
 580     if(fkMC->GetTrackRef()) momentum = fkMC->GetTrackRef()->P();
 581     pdg = fkMC->GetPDG();
 582   } else {
 583     //AliWarning("No MC info available!");
 584     momentum = cTrack.GetMomentum(0);
 585     pdg = CalcPDG(&cTrack);
 586   }
 587   if(!IsInRange(momentum)) return NULL;
 588
 589   (const_cast<AliTRDrecoParam*>(AliTRDinfoGen::Reconstructor()->GetRecoParam()))->SetPIDNeuralNetwork(kFALSE);
 590   Int_t iMomBin = fMomentumAxis->FindBin(momentum);
 591   Int_t species = AliTRDpidUtil::Pdg2Pid(pdg);
 592   Float_t *fdEdx;
 593   AliTRDseedV1 *tracklet = NULL;
 594   for(Int_t iChamb = 0; iChamb < AliTRDgeometry::kNlayer; iChamb++){
 595     tracklet = cTrack.GetTracklet(iChamb);
 596     if(!tracklet) continue;
 597     tracklet -> CookdEdx(AliTRDpidUtil::kLQslices);
 598     fdEdx = const_cast<Float_t *>(tracklet->GetdEdx());
 599     for(Int_t iSlice = 0; iSlice < AliTRDpidUtil::kLQslices; iSlice++){
 600       hdEdxSlice -> Fill(species * fMomentumAxis->GetNbins() * AliTRDpidUtil::kLQslices + (iMomBin-1) * AliTRDpidUtil::kLQslices + iSlice, fdEdx[iSlice]);
 601     }
 602   }
 603
 604   return hdEdxSlice;
 605 }
 606
 607
 608 //_______________________________________________________
 609 TH1 *AliTRDcheckPID::PlotPH(const AliTRDtrackV1 *track)
 610 {
 611   //
 612   // Plot the probabilities for electrons using 2-dim LQ
 613   //
 614
 615   if(track) fkTrack = track;
 616   if(!fkTrack){
 617     AliDebug(2, "No Track defined.");
 618     return NULL;
 619   }
 620
 621   if(!CheckTrackQuality(fkTrack)) return NULL;
 622
 623   TObjArray *arr = NULL;
 624   TProfile2D *hPHX, *hPHT;
 625   if(!(arr = dynamic_cast<TObjArray *>(fContainer->At(kPH)))){
 626     AliWarning("No Histogram defined.");
 627     return NULL;
 628   }
 629   hPHT = (TProfile2D*)arr->At(0);
 630   hPHX = (TProfile2D*)arr->At(1);
 631
 632   Int_t pdg = 0;
 633   Float_t momentum = 0.;
 634   if(fkMC){
 635     if(fkMC->GetTrackRef()) momentum = fkMC->GetTrackRef()->P();
 636     pdg = fkMC->GetPDG();
 637   } else {
 638     //AliWarning("No MC info available!");
 639     AliTRDtrackV1 cTrack(*fkTrack);
 640     cTrack.SetReconstructor(AliTRDinfoGen::Reconstructor());
 641     momentum = cTrack.GetMomentum(0);
 642     pdg = CalcPDG(&cTrack);
 643   }
 644   if(!IsInRange(momentum)) return NULL;;
 645
 646   AliTRDseedV1 *tracklet = NULL;
 647   AliTRDcluster *cluster = NULL;
 648   Int_t species = AliTRDpidUtil::Pdg2Pid(pdg);
 649   Int_t iBin = FindBin(species, momentum);
 650   for(Int_t iChamb = 0; iChamb < AliTRDgeometry::kNlayer; iChamb++){
 651     tracklet = fkTrack->GetTracklet(iChamb);
 652     if(!tracklet) continue;
 653     Float_t x0 = tracklet->GetX0();
 654     for(Int_t ic = 0; ic < AliTRDseedV1::kNclusters; ic++){
 655       if(!(cluster = tracklet->GetClusters(ic))) continue;
 656       hPHT -> Fill(iBin, cluster->GetLocalTimeBin(), TMath::Abs(cluster->GetQ()));
 657       if(ic<AliTRDseedV1::kNtb) hPHX -> Fill(iBin, x0 - cluster->GetX(), tracklet->GetdQdl(ic));
 658     }
 659   }
 660   return hPHT;
 661 }
 662
 663
 664 //_______________________________________________________
 665 TH1 *AliTRDcheckPID::PlotNClus(const AliTRDtrackV1 *track)
 666 {
 667   //
 668   // Plot the probabilities for electrons using 2-dim LQ
 669   //
 670
 671   if(track) fkTrack = track;
 672   if(!fkTrack){
 673     AliDebug(2, "No Track defined.");
 674     return NULL;
 675   }
 676
 677   if(!CheckTrackQuality(fkTrack)) return NULL;
 678
 679   TH2F *hNClus;
 680   if(!(hNClus = dynamic_cast<TH2F *>(fContainer->At(kNClus)))){
 681     AliWarning("No Histogram defined.");
 682     return NULL;
 683   }
 684
 685
 686   Int_t pdg = 0;
 687   Float_t momentum = 0.;
 688   if(fkMC){
 689     if(fkMC->GetTrackRef()) momentum = fkMC->GetTrackRef()->P();
 690     pdg = fkMC->GetPDG();
 691   } else {
 692     //AliWarning("No MC info available!");
 693     AliTRDtrackV1 cTrack(*fkTrack);
 694     cTrack.SetReconstructor(AliTRDinfoGen::Reconstructor());
 695     momentum = cTrack.GetMomentum(0);
 696     pdg = CalcPDG(&cTrack);
 697   }
 698   if(!IsInRange(momentum)) return NULL;
 699
 700   Int_t species = AliTRDpidUtil::AliTRDpidUtil::Pdg2Pid(pdg);
 701   Int_t iBin = FindBin(species, momentum);
 702   AliTRDseedV1 *tracklet = NULL;
 703   for(Int_t iChamb = 0; iChamb < AliTRDgeometry::kNlayer; iChamb++){
 704     tracklet = fkTrack->GetTracklet(iChamb);
 705     if(!tracklet) continue;
 706     hNClus -> Fill(iBin, tracklet->GetN());
 707   }
 708
 709   return hNClus;
 710 }
 711
 712 //_______________________________________________________
 713 TH1 *AliTRDcheckPID::PlotNTracklets(const AliTRDtrackV1 *track)
 714 {
 715   //
 716   // Plot the probabilities for electrons using 2-dim LQ
 717   //
 718
 719   if(track) fkTrack = track;
 720   if(!fkTrack){
 721     AliDebug(2, "No Track defined.");
 722     return NULL;
 723   }
 724
 725   TH2F *hTracklets;
 726   if(!(hTracklets = dynamic_cast<TH2F *>(fContainer->At(kNTracklets)))){
 727     AliWarning("No Histogram defined.");
 728     return NULL;
 729   }
 730
 731   AliTRDtrackV1 cTrack(*fkTrack);
 732   cTrack.SetReconstructor(AliTRDinfoGen::Reconstructor());
 733   Int_t pdg = 0;
 734   Float_t momentum = 0.;
 735   if(fkMC){
 736     if(fkMC->GetTrackRef()) momentum = fkMC->GetTrackRef()->P();
 737     pdg = fkMC->GetPDG();
 738   } else {
 739     //AliWarning("No MC info available!");
 740     momentum = cTrack.GetMomentum();
 741     pdg = CalcPDG(&cTrack);
 742   }
 743   Int_t species = AliTRDpidUtil::Pdg2Pid(pdg);
 744   if(!IsInRange(momentum)) return NULL;
 745
 746   Int_t iBin = FindBin(species, momentum);
 747   hTracklets -> Fill(iBin, cTrack.GetNumberOfTracklets());
 748   return hTracklets;
 749 }
 750
 751 //_______________________________________________________
 752 TH1 *AliTRDcheckPID::PlotMom(const AliTRDtrackV1 *track)
 753 {
 754   //
 755   // Plot the probabilities for electrons using 2-dim LQ
 756   //
 757
 758   if(track) fkTrack = track;
 759   if(!fkTrack){
 760     AliDebug(2, "No Track defined.");
 761     return NULL;
 762   }
 763
 764   if(!CheckTrackQuality(fkTrack)) return NULL;
 765
 766   TH1F *hMom;
 767   if(!(hMom = dynamic_cast<TH1F *>(fContainer->At(kMomentum)))){
 768     AliWarning("No Histogram defined.");
 769     return NULL;
 770   }
 771
 772
 773   Int_t pdg = 0;
 774   Float_t momentum = 0.;
 775   if(fkMC){
 776     if(fkMC->GetTrackRef()) momentum = fkMC->GetTrackRef()->P();
 777     pdg = fkMC->GetPDG();
 778   } else {
 779     //AliWarning("No MC info available!");
 780     AliTRDtrackV1 cTrack(*fkTrack);
 781     cTrack.SetReconstructor(AliTRDinfoGen::Reconstructor());
 782     momentum = cTrack.GetMomentum(0);
 783     pdg = CalcPDG(&cTrack);
 784   }
 785   if(IsInRange(momentum)) hMom -> Fill(momentum);
 786   return hMom;
 787 }
 788
 789
 790 //_______________________________________________________
 791 TH1 *AliTRDcheckPID::PlotMomBin(const AliTRDtrackV1 *track)
 792 {
 793   //
 794   // Plot the probabilities for electrons using 2-dim LQ
 795   //
 796
 797   if(track) fkTrack = track;
 798   if(!fkTrack){
 799     AliDebug(2, "No Track defined.");
 800     return NULL;
 801   }
 802
 803   if(!CheckTrackQuality(fkTrack)) return NULL;
 804
 805   TH1F *hMomBin;
 806   if(!(hMomBin = dynamic_cast<TH1F *>(fContainer->At(kMomentumBin)))){
 807     AliWarning("No Histogram defined.");
 808     return NULL;
 809   }
 810
 811
 812   Int_t pdg = 0;
 813   Float_t momentum = 0.;
 814
 815   if(fkMC){
 816     if(fkMC->GetTrackRef()) momentum = fkMC->GetTrackRef()->P();
 817     pdg = fkMC->GetPDG();
 818   } else {
 819     //AliWarning("No MC info available!");
 820     AliTRDtrackV1 cTrack(*fkTrack);
 821     cTrack.SetReconstructor(AliTRDinfoGen::Reconstructor());
 822     momentum = cTrack.GetMomentum(0);
 823   }
 824   if(IsInRange(momentum)) hMomBin -> Fill(fMomentumAxis->FindBin(momentum));
 825   return hMomBin;
 826 }
 827
 828 //_______________________________________________________
 829 TH1 *AliTRDcheckPID::PlotV0(const AliTRDtrackV1 *track)
 830 {
 831   //
 832   // Plot the V0 performance against MC
 833   //
 834
 835   if(track) fkTrack = track;
 836   if(!fkTrack){
 837     AliDebug(2, "No Track defined.");
 838     return NULL;
 839   }
 840   if(!fkESD->HasV0()) return NULL;
 841   if(!HasMCdata()){
 842     AliDebug(1, "No MC defined.");
 843     return NULL;
 844   }
 845   if(!fContainer){
 846     AliWarning("No output container defined.");
 847     return NULL;
 848   }
 849   AliDebug(2, Form("TRACK[%d] species[%s][%d]\n", fkESD->GetId(), fkMC->GetPID()>=0?AliPID::ParticleShortName(fkMC->GetPID()):"none", fkMC->GetPDG()));
 850
 851   TH1 *h(NULL);
 852   if(!(h = dynamic_cast<TH1F*>(fContainer->At(kV0)))) return NULL;
 853   Int_t sgn(0), n(0); AliTRDv0Info *v0(NULL);
 854   for(Int_t iv0(fV0s->GetEntriesFast()); iv0--;){
 855     if(!(v0=(AliTRDv0Info*)fV0s->At(iv0))) continue;
 856     if(!(sgn = v0->HasTrack(fkESD->GetId()))) continue;
 857     //for(Int_t is=AliPID::kSPECIES; is--;) v0->GetPID(is, track);
 858     //v0->Print();
 859     n++;
 860     //break;
 861   }
 862   h->Fill(n);
 863   return h;
 864 }
 865
 866 //________________________________________________________
 867 Bool_t AliTRDcheckPID::GetRefFigure(Int_t ifig)
 868 {
 869 // Steering function to retrieve performance plots
 870
 871   Bool_t kFIRST = kTRUE;
 872   TGraphErrors *g = NULL;
 873   TAxis *ax = NULL;
 874   TObjArray *arr = NULL;
 875   TH1 *h1 = NULL, *h=NULL;
 876   TH2 *h2 = NULL;
 877   TList *content = NULL;
 878   switch(ifig){
 879   case kEfficiency:{
 880     gPad->Divide(2, 1, 1.e-5, 1.e-5);
 881     TList *l=gPad->GetListOfPrimitives();
 882     TVirtualPad *pad = ((TVirtualPad*)l->At(0));pad->cd();
 883     pad->SetMargin(0.1, 0.01, 0.1, 0.01);
 884
 885     TLegend *legEff = new TLegend(.64, .84, .98, .98);
 886     legEff->SetBorderSize(1);legEff->SetTextSize(0.03255879);
 887     legEff->SetFillColor(0);
 888     h=new TH1S("hEff", "", 1, .5, 11.);
 889     h->SetLineColor(1);h->SetLineWidth(1);
 890     ax = h->GetXaxis();
 891     ax->SetTitle("p [GeV/c]");
 892     ax->SetRangeUser(.5, 11.);
 893     ax->SetMoreLogLabels();
 894     ax = h->GetYaxis();
 895     ax->SetTitle("#epsilon_{#pi} [%]");
 896     ax->CenterTitle();
 897     ax->SetRangeUser(1.e-2, 10.);
 898     h->Draw();
 899     content = (TList *)fGraph->FindObject(Form("Eff_%s", AliTRDCalPID::GetPartName(AliPID::kPion)));
 900     if(!(g = (TGraphErrors*)content->At(AliTRDpidUtil::kLQ))) break;
 901     if(!g->GetN()) break;
 902     legEff->SetHeader("PID Method [PION]");
 903     g->Draw("pc"); legEff->AddEntry(g, "LQ 2D", "pl");
 904     if(! (g = (TGraphErrors*)content->At(AliTRDpidUtil::kNN))) break;
 905     g->Draw("pc"); legEff->AddEntry(g, "NN", "pl");
 906     if(! (g = (TGraphErrors*)content->At(AliTRDpidUtil::kESD))) break;
 907     g->Draw("p"); legEff->AddEntry(g, "ESD", "pl");
 908     legEff->Draw();
 909     gPad->SetLogy();
 910     gPad->SetLogx();
 911     gPad->SetGridy();
 912     gPad->SetGridx();
 913
 914
 915     pad = ((TVirtualPad*)l->At(1));pad->cd();
 916     pad->SetMargin(0.1, 0.01, 0.1, 0.01);
 917     h=new TH1S("hThr", "", 1, .5, 11.);
 918     h->SetLineColor(1);h->SetLineWidth(1);
 919     ax = h->GetXaxis();
 920     ax->SetTitle("p [GeV/c]");
 921     ax->SetMoreLogLabels();
 922     ax = h->GetYaxis();
 923     ax->SetTitle("Threshold [%]");
 924     ax->SetRangeUser(5.e-2, 1.);
 925     h->Draw();
 926     content = (TList *)fGraph->FindObject("Thres");
 927     if(!(g = (TGraphErrors*)content->At(AliTRDpidUtil::kLQ))) break;
 928     if(!g->GetN()) break;
 929     g->Draw("pc");
 930     if(!(g = (TGraphErrors*)content->At(AliTRDpidUtil::kNN))) break;
 931     g->Draw("pc");
 932     if(!(g = (TGraphErrors*)content->At(AliTRDpidUtil::kESD))) break;
 933     g->Draw("p");
 934     gPad->SetLogx();
 935     gPad->SetGridy();
 936     gPad->SetGridx();
 937     return kTRUE;
 938   }
 939   case kEfficiencyKa:{
 940     gPad->Divide(2, 1, 1.e-5, 1.e-5);
 941     TList *l=gPad->GetListOfPrimitives();
 942     TVirtualPad *pad = ((TVirtualPad*)l->At(0));pad->cd();
 943     pad->SetMargin(0.1, 0.01, 0.1, 0.01);
 944
 945     TLegend *legEff = new TLegend(.64, .84, .98, .98);
 946     legEff->SetBorderSize(1);legEff->SetTextSize(0.03255879);
 947     legEff->SetFillColor(0);
 948     h = (TH1S*)gROOT->FindObject("hEff");
 949     h=(TH1S*)h->Clone("hEff_K");
 950     h->SetYTitle("#epsilon_{K} [%]");
 951     h->GetYaxis()->SetRangeUser(1.e-2, 1.e2);
 952     h->Draw();
 953     content = (TList *)fGraph->FindObject(Form("Eff_%s", AliTRDCalPID::GetPartName(AliPID::kKaon)));
 954     if(!(g = (TGraphErrors*)content->At(AliTRDpidUtil::kLQ))) break;
 955     if(!g->GetN()) break;
 956     legEff->SetHeader("PID Method [KAON]");
 957     g->Draw("pc"); legEff->AddEntry(g, "LQ 2D", "pl");
 958     if(! (g = (TGraphErrors*)content->At(AliTRDpidUtil::kNN))) break;
 959     g->Draw("pc"); legEff->AddEntry(g, "NN", "pl");
 960     if(! (g = (TGraphErrors*)content->At(AliTRDpidUtil::kESD))) break;
 961     g->Draw("p"); legEff->AddEntry(g, "ESD", "pl");
 962     legEff->Draw();
 963     gPad->SetLogy();
 964     gPad->SetLogx();
 965     gPad->SetGridy();
 966     gPad->SetGridx();
 967
 968     TLegend *legEff2 = new TLegend(.64, .84, .98, .98);
 969     legEff2->SetBorderSize(1);legEff2->SetTextSize(0.03255879);
 970     legEff2->SetFillColor(0);
 971     pad = ((TVirtualPad*)l->At(1));pad->cd();
 972     pad->SetMargin(0.1, 0.01, 0.1, 0.01);
 973     h=(TH1S*)h->Clone("hEff_p");
 974     h->SetYTitle("#epsilon_{p} [%]");
 975     h->GetYaxis()->SetRangeUser(1.e-2, 1.e2);
 976     h->Draw();
 977     content = (TList *)fGraph->FindObject(Form("Eff_%s", AliTRDCalPID::GetPartName(AliPID::kProton)));
 978     if(!(g = (TGraphErrors*)content->At(AliTRDpidUtil::kLQ))) break;
 979     if(!g->GetN()) break;
 980     legEff2->SetHeader("PID Method [PROTON]");
 981     g->Draw("pc"); legEff2->AddEntry(g, "LQ 2D", "pl");
 982     if(! (g = (TGraphErrors*)content->At(AliTRDpidUtil::kNN))) break;
 983     g->Draw("pc"); legEff2->AddEntry(g, "NN", "pl");
 984     if(! (g = (TGraphErrors*)content->At(AliTRDpidUtil::kESD))) break;
 985     g->Draw("p"); legEff2->AddEntry(g, "ESD", "pl");
 986     legEff2->Draw();
 987     gPad->SetLogy();
 988     gPad->SetLogx();
 989     gPad->SetGridy();
 990     gPad->SetGridx();
 991     return kTRUE;
 992   }
 993   case kdEdx:{
 994     // save 2.0 GeV projection as reference
 995     TLegend *legdEdx = new TLegend(.7, .7, .98, .98);
 996     legdEdx->SetBorderSize(1);
 997     kFIRST = kTRUE;
 998     if(!(h2 = (TH2F*)(fContainer->At(kdEdx)))) break;
 999     legdEdx->SetHeader("Particle Species");
1000     gPad->SetMargin(0.1, 0.01, 0.1, 0.01);
1001     for(Int_t is = AliPID::kSPECIES-1; is>=0; is--){
1002       Int_t bin = FindBin(is, 2.);
1003       h1 = h2->ProjectionY(Form("px%d", is), bin, bin);
1004       if(!h1->GetEntries()) continue;
1005       h1->Scale(1./h1->Integral());
1006       h1->SetLineColor(AliTRDCalPID::GetPartColor(is));
1007       if(kFIRST){
1008         h1->GetXaxis()->SetTitle("dE/dx (a.u.)");
1009         h1->GetYaxis()->SetTitle("<Entries>");
1010       }
1011       h = (TH1F*)h1->DrawClone(kFIRST ? "c" : "samec");
1012       legdEdx->AddEntry(h, Form("%s", AliTRDCalPID::GetPartName(is)), "l");
1013       kFIRST = kFALSE;
1014     }
1015     if(kFIRST) break;
1016     legdEdx->Draw();
1017     gPad->SetLogy();
1018     gPad->SetLogx(0);
1019     gPad->SetGridy();
1020     gPad->SetGridx();
1021     return kTRUE;
1022   }
1023   case kdEdxSlice:
1024     break;
1025   case kPH:{
1026     gPad->Divide(2, 1, 1.e-5, 1.e-5);
1027     TList *l=gPad->GetListOfPrimitives();
1028
1029     // save 2.0 GeV projection as reference
1030     TLegend *legPH = new TLegend(.4, .7, .68, .98);
1031     legPH->SetBorderSize(1);legPH->SetFillColor(0);
1032     legPH->SetHeader("Particle Species");
1033     if(!(arr = (TObjArray*)(fContainer->At(kPH)))) break;
1034     if(!(h2 = (TProfile2D*)(arr->At(0)))) break;
1035
1036     TVirtualPad *pad = ((TVirtualPad*)l->At(0));pad->cd();
1037     pad->SetMargin(0.1, 0.01, 0.1, 0.01);
1038     kFIRST = kTRUE;
1039     for(Int_t is=0; is<AliPID::kSPECIES; is++){
1040       Int_t bin = FindBin(is, 2.);
1041       h1 = h2->ProjectionY(Form("pyt%d", is), bin, bin);
1042       if(!h1->GetEntries()) continue;
1043       h1->SetMarkerStyle(24);
1044       h1->SetMarkerColor(AliTRDCalPID::GetPartColor(is));
1045       h1->SetLineColor(AliTRDCalPID::GetPartColor(is));
1046       if(kFIRST){
1047         h1->GetXaxis()->SetTitle("t_{drift} [100*ns]");
1048         h1->GetYaxis()->SetTitle("<dQ/dt> [a.u.]");
1049       }
1050       h = (TH1F*)h1->DrawClone(kFIRST ? "c" : "samec");
1051       legPH->AddEntry(h, Form("%s", AliTRDCalPID::GetPartName(is)), "pl");
1052       kFIRST = kFALSE;
1053     }
1054
1055     pad = ((TVirtualPad*)l->At(1));pad->cd();
1056     pad->SetMargin(0.1, 0.01, 0.1, 0.01);
1057     if(!(h2 = (TProfile2D*)(arr->At(1)))) break;
1058     kFIRST = kTRUE;
1059     for(Int_t is=0; is<AliPID::kSPECIES; is++){
1060       Int_t bin = FindBin(is, 2.);
1061       h1 = h2->ProjectionY(Form("pyx%d", is), bin, bin);
1062       if(!h1->GetEntries()) continue;
1063       h1->SetMarkerStyle(24);
1064       h1->SetMarkerColor(AliTRDCalPID::GetPartColor(is));
1065       h1->SetLineColor(AliTRDCalPID::GetPartColor(is));
1066       if(kFIRST){
1067         h1->GetXaxis()->SetTitle("x_{drift} [cm]");
1068         h1->GetYaxis()->SetTitle("<dQ/dl> [a.u./cm]");
1069       }
1070       h1->DrawClone(kFIRST ? "c" : "samec");
1071       kFIRST = kFALSE;
1072     }
1073
1074     if(kFIRST) break;
1075     legPH->Draw();
1076     gPad->SetLogy(0);
1077     gPad->SetLogx(0);
1078     gPad->SetGridy();
1079     gPad->SetGridx();
1080     return kTRUE;
1081   }
1082   case kNClus:{
1083     // save 2.0 GeV projection as reference
1084     TLegend *legNClus = new TLegend(.13, .7, .4, .98);
1085     legNClus->SetBorderSize(1);
1086     legNClus->SetFillColor(0);
1087
1088     kFIRST = kTRUE;
1089     if(!(h2 = (TH2F*)(fContainer->At(kNClus)))) break;
1090     legNClus->SetHeader("Particle Species");
1091     for(Int_t is=0; is<AliPID::kSPECIES; is++){
1092       Int_t bin = FindBin(is, 2.);
1093       h1 = h2->ProjectionY(Form("pyNClus%d", is), bin, bin);
1094       if(!h1->GetEntries()) continue;
1095       h1->Scale(100./h1->Integral());
1096       //h1->SetMarkerStyle(24);
1097       //h1->SetMarkerColor(AliTRDCalPID::GetPartColor(is));
1098       h1->SetLineColor(AliTRDCalPID::GetPartColor(is));
1099       if(kFIRST){
1100         h1->GetXaxis()->SetTitle("N^{cl}/tracklet");
1101         h1->GetYaxis()->SetTitle("Prob. [%]");
1102         h = (TH1F*)h1->DrawClone("c");
1103         h->SetMaximum(20.);
1104         h->GetXaxis()->SetRangeUser(0., 35.);
1105         kFIRST = kFALSE;
1106       } else h = (TH1F*)h1->DrawClone("samec");
1107
1108       legNClus->AddEntry(h, Form("%s", AliTRDCalPID::GetPartName(is)), "l");
1109     }
1110     if(kFIRST) break;
1111     legNClus->Draw();
1112     gPad->SetLogy(0);
1113     gPad->SetLogx(0);
1114     gPad->SetGridy();
1115     gPad->SetGridx();
1116     return kTRUE;
1117   }
1118   case kMomentum:
1119   case kMomentumBin:
1120     break;
1121   case kNTracklets:{
1122     TLegend *legNClus = new TLegend(.4, .7, .68, .98);
1123     legNClus->SetBorderSize(1);
1124     kFIRST = kTRUE;
1125     if(!(h2 = (TH2F*)(fContainer->At(kNTracklets)))) break;
1126     legNClus->SetHeader("Particle Species");
1127     for(Int_t is=0; is<AliPID::kSPECIES; is++){
1128       Int_t bin = FindBin(is, 2.);
1129       h1 = h2->ProjectionY(Form("pyNTracklets%d", is), bin, bin);
1130       if(!h1->GetEntries()) continue;
1131       h1->Scale(100./h1->Integral());
1132       //h1->SetMarkerStyle(24);
1133       //h1->SetMarkerColor(AliTRDCalPID::GetPartColor(is));
1134       h1->SetLineColor(AliTRDCalPID::GetPartColor(is));
1135       if(kFIRST){
1136         h1->GetXaxis()->SetTitle("N^{trklt}/track");
1137         h1->GetXaxis()->SetRangeUser(1.,6.);
1138         h1->GetYaxis()->SetTitle("Prob. [%]");
1139       }
1140       h = (TH1F*)h1->DrawClone(kFIRST ? "c" : "samec");
1141       legNClus->AddEntry(h, Form("%s", AliTRDCalPID::GetPartName(is)), "l");
1142       kFIRST = kFALSE;
1143     }
1144     if(kFIRST) break;
1145     legNClus->Draw();
1146     gPad->SetLogy(0);
1147     gPad->SetLogx(0);
1148     gPad->SetGridy();
1149     gPad->SetGridx();
1150     return kTRUE;
1151   }
1152   }
1153   AliInfo(Form("Reference plot [%d] missing result", ifig));
1154   return kFALSE;
1155 }
1156
1157 //________________________________________________________________________
1158 Bool_t AliTRDcheckPID::PostProcess()
1159 {
1160   // Draw result to the screen
1161   // Called once at the end of the query
1162
1163   if (!fContainer) {
1164     Printf("ERROR: list not available");
1165     return kFALSE;
1166   }
1167
1168   TObjArray *eff(NULL);
1169   if(!fGraph){
1170     fGraph = new TObjArray(2*AliPID::kSPECIES);
1171     fGraph->SetOwner();
1172
1173     if(!(eff = dynamic_cast<TObjArray *>(fContainer->At(kEfficiency)))){
1174       AliError("Efficiency container for Electrons missing.");
1175       return kFALSE;
1176     }
1177     EvaluateEfficiency(eff, fGraph, AliPID::kPion, 0.9);
1178     EvaluateEfficiency(eff, fGraph, AliPID::kKaon, 0.9);
1179     EvaluateEfficiency(eff, fGraph, AliPID::kProton, 0.9);
1180   }
1181   fNRefFigures = 12;
1182   return kTRUE;
1183 }
1184
1185 //________________________________________________________________________
1186 void AliTRDcheckPID::EvaluateEfficiency(const TObjArray * const histoContainer, TObjArray *results, Int_t species, Float_t electronEfficiency){
1187 // Process PID information for pion efficiency
1188
1189   fUtil->SetElectronEfficiency(electronEfficiency);
1190
1191
1192   const Int_t kNmethodsPID=Int_t(sizeof(fgMethod)/sizeof(Char_t*));
1193   Color_t colors[kNmethodsPID] = {kBlue, kGreen+2, kRed};
1194   Int_t markerStyle[kNmethodsPID] = {7, 7, 24};
1195   // efficiency graphs
1196   TGraphErrors *g(NULL);
1197   TObjArray *eff = new TObjArray(kNmethodsPID); eff->SetOwner(); eff->SetName(Form("Eff_%s", AliTRDCalPID::GetPartName(species)));
1198   results->AddAt(eff, species);
1199   for(Int_t iMethod = 0; iMethod < kNmethodsPID; iMethod++){
1200     eff->AddAt(g = new TGraphErrors(), iMethod);
1201     g->SetName(Form("%s", fgMethod[iMethod]));
1202     g->SetLineColor(colors[iMethod]);
1203     g->SetMarkerColor(colors[iMethod]);
1204     g->SetMarkerStyle(markerStyle[iMethod]);
1205   }
1206
1207   // Threshold graphs if not already
1208   TObjArray *thres(NULL);
1209   if(!(results->At(AliPID::kSPECIES))){
1210     thres = new TObjArray(kNmethodsPID); thres->SetOwner();
1211     thres->SetName("Thres");
1212     results->AddAt(thres, AliPID::kSPECIES);
1213     for(Int_t iMethod = 0; iMethod < kNmethodsPID; iMethod++){
1214       thres->AddAt(g = new TGraphErrors(), iMethod);
1215       g->SetName(Form("%s", fgMethod[iMethod]));
1216       g->SetLineColor(colors[iMethod]);
1217       g->SetMarkerColor(colors[iMethod]);
1218       g->SetMarkerStyle(markerStyle[iMethod]);
1219     }
1220   }
1221
1222   TH2F *hPtr[kNmethodsPID]={
1223     (TH2F*)histoContainer->At(AliTRDpidUtil::kLQ),
1224     (TH2F*)histoContainer->At(AliTRDpidUtil::kNN),
1225     (TH2F*)histoContainer->At(AliTRDpidUtil::kESD)
1226   };
1227   for(Int_t iMom = 0; iMom < fMomentumAxis->GetNbins(); iMom++){
1228     Float_t mom(fMomentumAxis->GetBinCenter(iMom+1));
1229
1230     Int_t binEl(fMomentumAxis->GetNbins() * AliPID::kElectron + iMom + 1),
1231                 binXX(fMomentumAxis->GetNbins() * species + iMom + 1);
1232
1233     for(Int_t iMethod = 0; iMethod < kNmethodsPID; iMethod++){
1234       // Calculate the Species Efficiency at electronEfficiency% electron efficiency for each Method
1235
1236       TH1D *histo1 = hPtr[iMethod] -> ProjectionY(Form("%s_el", fgMethod[iMethod]), binEl, binEl);
1237       TH1D *histo2 = hPtr[iMethod] -> ProjectionY(Form("%s_%s", fgMethod[iMethod], AliTRDCalPID::GetPartName(species)), binXX, binXX);
1238
1239       if(!fUtil->CalculatePionEffi(histo1, histo2)) continue;
1240
1241       g=(TGraphErrors*)eff->At(iMethod);
1242       g->SetPoint(iMom, mom, 1.e2*fUtil->GetPionEfficiency());
1243       g->SetPointError(iMom, 0., 1.e2*fUtil->GetError());
1244       AliDebug(2, Form("%s Efficiency for %s is : %f +/- %f", AliTRDCalPID::GetPartName(species), fgMethod[iMethod], fUtil->GetPionEfficiency(), fUtil->GetError()));
1245
1246       if(!thres) continue;
1247       g=(TGraphErrors*)thres->At(iMethod);
1248       g->SetPoint(iMom, mom, fUtil->GetThreshold());
1249       g->SetPointError(iMom, 0., 0.);
1250     }
1251   }
1252 }