new plots for the PID tasks (ESD PID monitor and threshold) (AlexB AlexW)

diff --git a/TRD/AliTRDpidUtil.cxx b/TRD/AliTRDpidUtil.cxx
index 15f6103289aa6626b7e9fafa613dd331c0fb49e9..b78c226019f556065ddef62c533818b1f95aaad7 100644 (file)
--- a/TRD/AliTRDpidUtil.cxx
+++ b/TRD/AliTRDpidUtil.cxx
@@ -30,7 +30,7 @@ AliTRDpidUtil::AliTRDpidUtil()
 
 
 //________________________________________________________________________
-void  AliTRDpidUtil::CalculatePionEffi(TH1* histo1, TH1* histo2)
+Bool_t  AliTRDpidUtil::CalculatePionEffi(TH1* histo1, TH1* histo2)
 // Double_t  AliTRDpidUtil::GetError()
 {
   //
@@ -39,10 +39,9 @@ void  AliTRDpidUtil::CalculatePionEffi(TH1* histo1, TH1* histo2)
 
   histo1 -> SetLineColor(kRed);
   histo2 -> SetLineColor(kBlue); 
-  AliInfo(Form("Histo1[%d] Histo2[%d]", (Int_t)histo1 -> GetEntries(), (Int_t)histo2 -> GetEntries()));
-  if(!(histo1 -> GetEntries() > 0 && histo2 -> GetEntries() > 0)){
-    AliWarning("Histo has no Entries !");
-    return;
+  if(!histo1 -> GetEntries() || !histo2 -> GetEntries()){
+    AliWarning("Histo with no entries !");
+    return kFALSE;
   }
   histo1 -> Scale(1./histo1->GetEntries());
   histo2 -> Scale(1./histo2->GetEntries());
@@ -84,22 +83,22 @@ void  AliTRDpidUtil::CalculatePionEffi(TH1* histo1, TH1* histo2)
   
 
   // pion efficiency vs electron efficiency
-  TGraph *gEffis = new TGraph(kBins, SumElecsE, SumPionsE);
+  TGraph gEffis(kBins, SumElecsE, SumPionsE);
 
   // use fit function to get derivate of the TGraph for error calculation
-  TF1 *f1 = new TF1("f1","[0]*x*x+[1]*x+[2]", fEleEffi-.05, fEleEffi+.05);
-  gEffis -> Fit("f1","Q","",fEleEffi-.05, fEleEffi+.05);
+  TF1 f1("f1","[0]*x*x+[1]*x+[2]", fEleEffi-.05, fEleEffi+.05);
+  gEffis.Fit(&f1, "Q", "", fEleEffi-.05, fEleEffi+.05);
   
   // return the error of the pion efficiency
   if(((1.-fPionEffi) < 0) || ((1.-fCalcEleEffi) < 0)){
     AliWarning(" EleEffi or PioEffi > 1. Error can not be calculated. Please increase statistics or check your simulation!");
-    return;
+    return kFALSE;
   }
-  fError = sqrt(((1/histo2 -> GetEntries())*fPionEffi*(1-fPionEffi))+((f1 -> Derivative(fEleEffi))*(f1 -> Derivative(fEleEffi))*(1/histo1 -> GetEntries())*fCalcEleEffi*(1-fCalcEleEffi)));
-
-  AliInfo(Form("Pion Effi at [%f] : [%f +/- %f], Threshold[%f]", fCalcEleEffi, fPionEffi, fError, fThreshold));
-  AliInfo(Form("Derivative at %4.2f : %f\n", fEleEffi, f1 -> Derivative(fEleEffi)));
+  fError = sqrt(((1/histo2 -> GetEntries())*fPionEffi*(1-fPionEffi))+((f1.Derivative(fEleEffi))*(f1.Derivative(fEleEffi))*(1/histo1 -> GetEntries())*fCalcEleEffi*(1-fCalcEleEffi)));
 
+//   AliInfo(Form("Pion Effi at [%f] : [%f +/- %f], Threshold[%f]", fCalcEleEffi, fPionEffi, fError, fThreshold));
+//   AliInfo(Form("Derivative at %4.2f : %f\n", fEleEffi, f1.Derivative(fEleEffi)));
+  return kTRUE;
 }
 
 

diff --git a/TRD/AliTRDpidUtil.h b/TRD/AliTRDpidUtil.h
index 7abab04e9c9bef4c08f690947c3c9628a0196a70..31c349f2e75908838ee5d45e2ca53fe10b52fd7d 100644 (file)
--- a/TRD/AliTRDpidUtil.h
+++ b/TRD/AliTRDpidUtil.h
@@ -20,7 +20,7 @@ public:
   AliTRDpidUtil();
   virtual ~AliTRDpidUtil(){;}
 
-  void     CalculatePionEffi(TH1* histo1, TH1* histo2);
+  Bool_t   CalculatePionEffi(TH1* histo1, TH1* histo2);
 
   static Float_t ElectronEfficiency() { return fEleEffi;};
 

diff --git a/TRD/qaRec/AliTRDpidChecker.cxx b/TRD/qaRec/AliTRDpidChecker.cxx
index 3bb6b7523b5a513d933cdc08f2747f3ed0248afb..ce03a6f2480ef8e4c94adca0e37edc8af22968a5 100644 (file)
--- a/TRD/qaRec/AliTRDpidChecker.cxx
+++ b/TRD/qaRec/AliTRDpidChecker.cxx
@@ -8,6 +8,7 @@
 #include "TProfile2D.h"
 #include "TGraph.h"
 #include "TGraphErrors.h"
+#include "TLegend.h"
 
 #include <TClonesArray.h>
 #include <TObjArray.h>
@@ -39,6 +40,8 @@ AliTRDpidChecker::AliTRDpidChecker()
   :AliTRDrecoTask("PID", "PID Checker")
   ,fReconstructor(0x0)
   ,fUtil(0x0)
+  ,fGraph(0x0)
+  ,fEfficiency(0x0)
 {
   //
   // Default constructor
@@ -56,7 +59,8 @@ AliTRDpidChecker::AliTRDpidChecker()
 //________________________________________________________________________
 AliTRDpidChecker::~AliTRDpidChecker() 
 {
-  if(fReconstructor) delete fReconstructor;
+ if(fGraph){fGraph->Delete(); delete fGraph;}
+ if(fReconstructor) delete fReconstructor;
   if(fUtil) delete fUtil;
 }
 
@@ -81,25 +85,32 @@ TObjArray * AliTRDpidChecker::Histos(){
   if(fContainer) return fContainer;
 
   Int_t xBins = AliPID::kSPECIES*AliTRDCalPID::kNMom; 
-  fContainer = new TObjArray();
-  fContainer -> Expand(kGraphNN + 1);
+  fContainer = new TObjArray(); fContainer->Expand(7);
 
   const Float_t epsilon = 1./(2*(AliTRDpidUtil::kBins-1));     // get nice histos with bin center at 0 and 1
 
   // histos of the electron probability of all 5 particle species and 11 momenta for the 2-dim LQ method 
-  fContainer->AddAt(
-    new TH2F("PID_LQ", "", 
+  fEfficiency = new TObjArray(); fEfficiency->Expand(3);
+  fContainer->AddAt(fEfficiency, kEfficiency);
+  fEfficiency->AddAt(new TH2F("PID_LQ", "", 
       xBins, -0.5, xBins - 0.5,
       AliTRDpidUtil::kBins, 0.-epsilon, 1.+epsilon)
-  ,kLQlikelihood);
+  ,kLQ);
 
 
   // histos of the electron probability of all 5 particle species and 11 momenta for the neural network method
-  fContainer->AddAt(
+  fEfficiency->AddAt(
     new TH2F("PID_NN", "", 
       xBins, -0.5, xBins - 0.5,
       AliTRDpidUtil::kBins, 0.-epsilon, 1.+epsilon)
-  ,kNNlikelihood);
+  ,kNN);
+
+  // histos of the electron probability of all 5 particle species and 11 momenta for the ESD output
+  fEfficiency->AddAt(
+    new TH2F("PID_ESD", "", 
+      xBins, -0.5, xBins - 0.5,
+      AliTRDpidUtil::kBins, 0.-epsilon, 1.+epsilon)
+  ,kESD);
 
   // histos of the dE/dx distribution for all 5 particle species and 11 momenta 
   fContainer->AddAt(
@@ -108,7 +119,7 @@ TObjArray * AliTRDpidChecker::Histos(){
       200, 0, 10000)
     ,kdEdx);
 
-  // histos of the dE/dx distribution for all 5 particle species and 11 momenta 
+  // histos of the dE/dx slices for all 5 particle species and 11 momenta 
   fContainer->AddAt(
     new TH2F("dEdxSlice", "", 
       xBins*AliTRDReconstructor::kLQslices, -0.5, xBins*AliTRDReconstructor::kLQslices - 0.5,
@@ -135,24 +146,6 @@ TObjArray * AliTRDpidChecker::Histos(){
   fContainer->AddAt(new TH1F("hMomBin", "momentum distribution in momentum bins", AliTRDCalPID::kNMom, 0.5, 11.5),kMomentumBin);
 
 
-  // TGraph of the pion efficiencies
-
-  TGraphErrors *gEffisLQ = 0x0;
-  TGraphErrors *gEffisNN = 0x0;
-
-  fContainer->AddAt(gEffisLQ = new TGraphErrors(), kGraphLQ);
-  gEffisLQ->SetLineColor(kBlue);
-  gEffisLQ->SetMarkerColor(kBlue);
-  gEffisLQ->SetMarkerStyle(29);
-
-  fContainer -> AddAt(gEffisNN = new TGraphErrors(),kGraphNN);
-  gEffisNN->SetLineColor(kRed);
-  gEffisNN->SetMarkerColor(kRed);
-  gEffisNN->SetMarkerStyle(29);
-
-  gEffisLQ -> SetNameTitle("gEffisLQErr", "Efficiencies and Errors of the 2-dim LQ method");
-  gEffisNN -> SetNameTitle("gEffisNNErr", "Efficiencies and Errors of the NN method");
-
   return fContainer;
 }
 
@@ -214,8 +207,12 @@ TH1 *AliTRDpidChecker::PlotLQ(const AliTRDtrackV1 *track)
 
   if(!CheckTrackQuality(fTrack)) return 0x0;
   
-  TH2F *hPIDLQ;
-  if(!(hPIDLQ = dynamic_cast<TH2F *>(fContainer->At(kLQlikelihood)))){
+  if(!(fEfficiency = dynamic_cast<TObjArray *>(fContainer->At(kEfficiency)))){
+    AliWarning("No Histogram defined.");
+    return 0x0;
+  }
+  TH2F *hPIDLQ = 0x0;
+  if(!(hPIDLQ = dynamic_cast<TH2F *>(fEfficiency->At(kLQ)))){
     AliWarning("No Histogram defined.");
     return 0x0;
   }
@@ -234,15 +231,12 @@ TH1 *AliTRDpidChecker::PlotLQ(const AliTRDtrackV1 *track)
     momentum = cTrack.GetMomentum(0);
     pdg = CalcPDG(&cTrack);
   }
-
+  if(momentum < 0.4) return 0x0;;
+  if(momentum > 12.) return 0x0;;
 
   fReconstructor -> SetOption("!nn");
   cTrack.CookPID();
-
-  Int_t iMomBin = -1;
-  iMomBin = fUtil->GetMomentumBin(momentum);
-
-  if(momentum < 0.4) return 0x0;;
+  Int_t iMomBin = fUtil->GetMomentumBin(momentum);
 
   switch(pdg){
   case kElectron:
@@ -286,8 +280,12 @@ TH1 *AliTRDpidChecker::PlotNN(const AliTRDtrackV1 *track)
   
   if(!CheckTrackQuality(fTrack)) return 0x0;
   
+  if(!(fEfficiency = dynamic_cast<TObjArray *>(fContainer->At(kEfficiency)))){
+    AliWarning("No Histogram defined.");
+    return 0x0;
+  }
   TH2F *hPIDNN;
-  if(!(hPIDNN = dynamic_cast<TH2F *>(fContainer->At(kNNlikelihood)))){
+  if(!(hPIDNN = dynamic_cast<TH2F *>(fContainer->At(kNN)))){
     AliWarning("No Histogram defined.");
     return 0x0;
   }
@@ -298,7 +296,6 @@ TH1 *AliTRDpidChecker::PlotNN(const AliTRDtrackV1 *track)
 
   Int_t pdg = 0;
   Float_t momentum = 0.;
-
   if(fMC){
     if(fMC->GetTrackRef()) momentum = fMC->GetTrackRef()->P();
     pdg = fMC->GetPDG();
@@ -307,15 +304,12 @@ TH1 *AliTRDpidChecker::PlotNN(const AliTRDtrackV1 *track)
     momentum = cTrack.GetMomentum(0);
     pdg = CalcPDG(&cTrack);
   }
-
+  if(momentum < 0.4) return 0x0;;
+  if(momentum > 12.) return 0x0;;
 
   fReconstructor -> SetOption("nn");
   cTrack.CookPID();
-
-  Int_t iMomBin = -1;
-  iMomBin = fUtil -> GetMomentumBin(momentum);
-
-  if(momentum < 0.4) return 0x0;;
+  Int_t iMomBin = fUtil -> GetMomentumBin(momentum);
 
   switch(pdg){
   case kElectron:
@@ -343,6 +337,85 @@ TH1 *AliTRDpidChecker::PlotNN(const AliTRDtrackV1 *track)
 }
 
 
+//_______________________________________________________
+TH1 *AliTRDpidChecker::PlotESD(const AliTRDtrackV1 *track)
+{
+  //
+  // Plot the probabilities for electrons using 2-dim LQ
+  //
+
+  if(!fESD){
+    AliWarning("No ESD info available.");
+    return 0x0;
+  }
+
+  if(track) fTrack = track;
+  if(!fTrack){
+    AliWarning("No Track defined.");
+    return 0x0;
+  }
+  
+  if(!CheckTrackQuality(fTrack)) return 0x0;
+  
+  if(!(fEfficiency = dynamic_cast<TObjArray *>(fContainer->At(kEfficiency)))){
+    AliWarning("No Histogram defined.");
+    return 0x0;
+  }
+  TH2F *hPIDESD = 0x0;
+  if(!(hPIDESD = dynamic_cast<TH2F *>(fContainer->At(kESD)))){
+    AliWarning("No Histogram defined.");
+    return 0x0;
+  }
+
+
+  Int_t pdg = 0;
+  Float_t momentum = 0.;
+  if(fMC){
+    if(fMC->GetTrackRef()) momentum = fMC->GetTrackRef()->P();
+    pdg = fMC->GetPDG();
+  } else {
+    //AliWarning("No MC info available!");
+    AliTRDtrackV1 cTrack(*fTrack);
+    cTrack.SetReconstructor(fReconstructor);
+    momentum = cTrack.GetMomentum(0);
+    pdg = CalcPDG(&cTrack);
+  }
+  if(momentum < 0.4) return 0x0;;
+  if(momentum > 12.) return 0x0;;
+  
+
+  Int_t iMomBin = fUtil->GetMomentumBin(momentum);
+
+
+//   Double32_t pidESD[AliPID::kSPECIES];
+  const Double32_t *pidESD = fESD->GetResponseIter();
+
+  switch(pdg){
+  case kElectron:
+  case kPositron:
+    hPIDESD -> Fill(AliPID::kElectron * AliTRDCalPID::kNMom + iMomBin, pidESD[0]);
+    break;
+  case kMuonPlus:
+  case kMuonMinus:
+    hPIDESD -> Fill(AliPID::kMuon * AliTRDCalPID::kNMom + iMomBin, pidESD[0]);
+    break;
+  case kPiPlus:
+  case kPiMinus:
+    hPIDESD -> Fill(AliPID::kPion * AliTRDCalPID::kNMom + iMomBin, pidESD[0]);
+    break;
+  case kKPlus:
+  case kKMinus:
+    hPIDESD -> Fill(AliPID::kKaon * AliTRDCalPID::kNMom + iMomBin, pidESD[0]);
+    break;
+  case kProton:
+  case kProtonBar:
+    hPIDESD -> Fill(AliPID::kProton * AliTRDCalPID::kNMom + iMomBin, pidESD[0]);
+    break;
+  }
+  return hPIDESD;
+}
+
+
 //_______________________________________________________
 TH1 *AliTRDpidChecker::PlotdEdx(const AliTRDtrackV1 *track)
 {
@@ -365,25 +438,24 @@ TH1 *AliTRDpidChecker::PlotdEdx(const AliTRDtrackV1 *track)
   }
 
 
-  AliTRDtrackV1 cTrack(*fTrack);
-  cTrack.SetReconstructor(fReconstructor);
-
   Int_t pdg = 0;
   Float_t momentum = 0.;
-
   if(fMC){
     if(fMC->GetTrackRef()) momentum = fMC->GetTrackRef()->P();
     pdg = fMC->GetPDG();
   } else {
     //AliWarning("No MC info available!");
+    AliTRDtrackV1 cTrack(*fTrack);
+    cTrack.SetReconstructor(fReconstructor);
     momentum = cTrack.GetMomentum(0);
     pdg = CalcPDG(&cTrack);
   }
+  if(momentum < 0.4) return 0x0;;
+  if(momentum > 12.) return 0x0;;
+
+  Int_t iMomBin = fUtil -> GetMomentumBin(momentum);
 
-  Int_t iMomBin = -1;
-  iMomBin = fUtil -> GetMomentumBin(momentum);
 
-  if(momentum < 0.4) return 0x0;;
 
   Float_t SumdEdx[AliTRDgeometry::kNlayer];
   AliTRDseedV1 *TRDtracklet[AliTRDgeometry::kNlayer];
@@ -455,26 +527,24 @@ TH1 *AliTRDpidChecker::PlotdEdxSlice(const AliTRDtrackV1 *track)
     return 0x0;
   }
 
-
-  AliTRDtrackV1 cTrack(*fTrack);
-  cTrack.SetReconstructor(fReconstructor);
-
   Int_t pdg = 0;
   Float_t momentum = 0.;
-
   if(fMC){
     if(fMC->GetTrackRef()) momentum = fMC->GetTrackRef()->P();
     pdg = fMC->GetPDG();
   } else {
     //AliWarning("No MC info available!");
+    AliTRDtrackV1 cTrack(*fTrack);
+    cTrack.SetReconstructor(fReconstructor);
     momentum = cTrack.GetMomentum(0);
     pdg = CalcPDG(&cTrack);
   }
+  if(momentum < 0.4) return 0x0;
+  if(momentum > 12.) return 0x0;;
+
+  Int_t iMomBin = fUtil -> GetMomentumBin(momentum);
 
-  Int_t iMomBin = -1;
-  iMomBin = fUtil -> GetMomentumBin(momentum);
 
-  if(momentum < 0.4) return 0x0;
 
   AliTRDseedV1 *TRDtracklet[AliTRDgeometry::kNlayer];
   for(Int_t iChamb = 0; iChamb < AliTRDgeometry::kNlayer; iChamb++) TRDtracklet[iChamb] = 0x0;
@@ -493,17 +563,20 @@ TH1 *AliTRDpidChecker::PlotdEdxSlice(const AliTRDtrackV1 *track)
   switch(pdg){
   case kElectron:
   case kPositron:
-    for(Int_t iChamb = 0; iChamb < AliTRDgeometry::kNlayer; iChamb++)
-      for(Int_t iSlice = 0; iSlice < AliTRDReconstructor::kLQslices; iSlice++)
-       hdEdxSlice -> Fill(AliPID::kElectron * AliTRDCalPID::kNMom * AliTRDReconstructor::kLQslices + iMomBin * AliTRDReconstructor::kLQslices + iSlice,
-                          dEdxSlice[iChamb][iSlice]);
+    for(Int_t iChamb = 0; iChamb < AliTRDgeometry::kNlayer; iChamb++){
+      for(Int_t iSlice = 0; iSlice < AliTRDReconstructor::kLQslices; iSlice++){
+        hdEdxSlice -> Fill(AliPID::kElectron * AliTRDCalPID::kNMom * AliTRDReconstructor::kLQslices + iMomBin * AliTRDReconstructor::kLQslices + iSlice, dEdxSlice[iChamb][iSlice]);
+      }
+    }  
     break;
   case kMuonPlus:
   case kMuonMinus:
-    for(Int_t iChamb = 0; iChamb < AliTRDgeometry::kNlayer; iChamb++)
-      for(Int_t iSlice = 0; iSlice < AliTRDReconstructor::kLQslices; iSlice++)
-       hdEdxSlice -> Fill(AliPID::kMuon * AliTRDCalPID::kNMom * AliTRDReconstructor::kLQslices + iMomBin * AliTRDReconstructor::kLQslices + iSlice,
-                          dEdxSlice[iChamb][iSlice]);
+    for(Int_t iChamb = 0; iChamb < AliTRDgeometry::kNlayer; iChamb++){
+      for(Int_t iSlice = 0; iSlice < AliTRDReconstructor::kLQslices; iSlice++){
+        hdEdxSlice -> Fill(AliPID::kMuon * AliTRDCalPID::kNMom * AliTRDReconstructor::kLQslices + iMomBin * AliTRDReconstructor::kLQslices + iSlice,
+        dEdxSlice[iChamb][iSlice]);
+      }
+    }
     break;
   case kPiPlus:
   case kPiMinus:
@@ -554,26 +627,22 @@ TH1 *AliTRDpidChecker::PlotPH(const AliTRDtrackV1 *track)
     return 0x0;
   }
 
-
-  AliTRDtrackV1 cTrack(*fTrack);
-  cTrack.SetReconstructor(fReconstructor);
-
   Int_t pdg = 0;
   Float_t momentum = 0.;
-
   if(fMC){
     if(fMC->GetTrackRef()) momentum = fMC->GetTrackRef()->P();
     pdg = fMC->GetPDG();
   } else {
     //AliWarning("No MC info available!");
+    AliTRDtrackV1 cTrack(*fTrack);
+    cTrack.SetReconstructor(fReconstructor);
     momentum = cTrack.GetMomentum(0);
     pdg = CalcPDG(&cTrack);
   }
-
-  Int_t iMomBin = -1;
-  iMomBin = fUtil -> GetMomentumBin(momentum);
-
   if(momentum < 0.4) return 0x0;;
+  if(momentum > 12.) return 0x0;;
+
+  Int_t iMomBin = fUtil -> GetMomentumBin(momentum);
 
   AliTRDseedV1 *TRDtracklet[AliTRDgeometry::kNlayer];
   for(Int_t iChamb = 0; iChamb < AliTRDgeometry::kNlayer; iChamb++) TRDtracklet[iChamb] = 0x0;
@@ -660,25 +729,23 @@ TH1 *AliTRDpidChecker::PlotNClus(const AliTRDtrackV1 *track)
   }
 
 
-  AliTRDtrackV1 cTrack(*fTrack);
-  cTrack.SetReconstructor(fReconstructor);
-
   Int_t pdg = 0;
   Float_t momentum = 0.;
-
   if(fMC){
     if(fMC->GetTrackRef()) momentum = fMC->GetTrackRef()->P();
     pdg = fMC->GetPDG();
   } else {
     //AliWarning("No MC info available!");
+    AliTRDtrackV1 cTrack(*fTrack);
+    cTrack.SetReconstructor(fReconstructor);
     momentum = cTrack.GetMomentum(0);
     pdg = CalcPDG(&cTrack);
   }
+  if(momentum < 0.4) return 0x0;;
+  if(momentum > 12.) return 0x0;;
 
-  Int_t iMomBin = -1;
-  iMomBin = fUtil -> GetMomentumBin(momentum);
+  Int_t iMomBin = fUtil -> GetMomentumBin(momentum);
 
-  if(momentum < 0.4) return 0x0;;
 
   Int_t iNClus[AliTRDgeometry::kNlayer]; 
   memset(iNClus, 0, sizeof(Int_t) * AliTRDgeometry::kNlayer);
@@ -744,22 +811,20 @@ TH1 *AliTRDpidChecker::PlotMom(const AliTRDtrackV1 *track)
   }
 
 
-  AliTRDtrackV1 cTrack(*fTrack);
-  cTrack.SetReconstructor(fReconstructor);
-
   Int_t pdg = 0;
   Float_t momentum = 0.;
-
   if(fMC){
     if(fMC->GetTrackRef()) momentum = fMC->GetTrackRef()->P();
     pdg = fMC->GetPDG();
   } else {
     //AliWarning("No MC info available!");
+    AliTRDtrackV1 cTrack(*fTrack);
+    cTrack.SetReconstructor(fReconstructor);
     momentum = cTrack.GetMomentum(0);
     pdg = CalcPDG(&cTrack);
   }
-
   if(momentum < 0.4) return 0x0;
+  if(momentum > 12.) return 0x0;;
 
   hMom -> Fill(momentum);
   return hMom;
@@ -788,9 +853,6 @@ TH1 *AliTRDpidChecker::PlotMomBin(const AliTRDtrackV1 *track)
   }
 
 
-  AliTRDtrackV1 cTrack(*fTrack);
-  cTrack.SetReconstructor(fReconstructor);
-
   Int_t pdg = 0;
   Float_t momentum = 0.;
 
@@ -799,15 +861,15 @@ TH1 *AliTRDpidChecker::PlotMomBin(const AliTRDtrackV1 *track)
     pdg = fMC->GetPDG();
   } else {
     //AliWarning("No MC info available!");
+    AliTRDtrackV1 cTrack(*fTrack);
+    cTrack.SetReconstructor(fReconstructor);
     momentum = cTrack.GetMomentum(0);
     pdg = CalcPDG(&cTrack);
   }
-
-  Int_t iMomBin = -1;
-  iMomBin = fUtil -> GetMomentumBin(momentum);
-
   if(momentum < 0.4) return 0x0;
+  if(momentum > 12.) return 0x0;;
 
+  Int_t iMomBin = fUtil -> GetMomentumBin(momentum);
   hMomBin -> Fill(iMomBin);
   return hMomBin;
 }
@@ -817,44 +879,65 @@ TH1 *AliTRDpidChecker::PlotMomBin(const AliTRDtrackV1 *track)
 void AliTRDpidChecker::GetRefFigure(Int_t ifig)
 {
   Bool_t FIRST = kTRUE;
+  TLegend *leg = new TLegend(.7, .7, .98, .98);
+  leg->SetBorderSize(1);
   TGraphErrors *g = 0x0;
-  TH1 *h1 = 0x0;
+  TAxis *ax = 0x0;
+  TH1 *h1 = 0x0, *h=0x0;
   TH2 *h2 = 0x0;
   switch(ifig){
-  case 0:
-    g = (TGraphErrors*)fContainer->At(kGraphStart);
+  case kEfficiency:
+    if(!(g = (TGraphErrors*)fGraph->At(kLQ))) break;
+    if(!g->GetN()) break;
+    leg->SetHeader("PID Method");
     g->Draw("apl");
-    g->GetHistogram()->GetXaxis()->SetTitle("p [GeV/c]");
-    g->GetHistogram()->GetXaxis()->SetRangeUser(.6, 10.5);
+    ax = g->GetHistogram()->GetXaxis();
+    ax->SetTitle("p [GeV/c]");
+    ax->SetRangeUser(.6, 10.5);
+    ax->SetMoreLogLabels();
     g->GetHistogram()->GetYaxis()->SetTitle("#epsilon_{#pi} [%]");
-    ((TGraphErrors*)fContainer->At(kGraphStart+1))->Draw("pl");
+    leg->AddEntry(g, "2D LQ", "pl");
+    if(! (g = (TGraphErrors*)fGraph->At(kNN))) break;
+    g->Draw("pl");
+    leg->AddEntry(g, "NN", "pl");
+    if(! (g = (TGraphErrors*)fGraph->At(kESD))) break;
+    g->Draw("pl");
+    leg->AddEntry(g, "ESD", "pl");
+    leg->Draw();
     gPad->SetLogy();
     gPad->SetLogx();
     gPad->SetGridy();
     gPad->SetGridx();
-    break;
-  case 1:
+    return;
+  case kdEdx:
     // save 2.0 GeV projection as reference
     FIRST = kTRUE;
-    h2 = (TH2F*)(fContainer->At(kdEdx));
+    if(!(h2 = (TH2F*)(fContainer->At(kdEdx)))) break;
+    leg->SetHeader("Particle Species");
     for(Int_t is = AliPID::kSPECIES-1; is>=0; is--){
       Int_t bin = is*AliTRDCalPID::kNMom+4;
       h1 = h2->ProjectionY("px", bin, bin);
       if(!h1->GetEntries()) continue;
       h1->Scale(1./h1->Integral());
       h1->SetLineColor(AliTRDCalPID::GetPartColor(is));
-      h1->DrawClone(FIRST ? "c" : "samec");
+      h = (TH1F*)h1->DrawClone(FIRST ? "c" : "samec");
+      leg->AddEntry(h, Form("%s", AliTRDCalPID::GetPartName(is)), "pl");
       FIRST = kFALSE;
     }
+    if(FIRST) break;
+    leg->Draw();
     gPad->SetLogy();
     gPad->SetLogx(0);
     gPad->SetGridy();
     gPad->SetGridx();
+    return;
+  case kdEdxSlice:
     break;
-  case 2:
+  case kPH:
     // save 2.0 GeV projection as reference
     FIRST = kTRUE;
-    h2 = (TH2F*)(fContainer->At(kPH));
+    if(!(h2 = (TH2F*)(fContainer->At(kPH)))) break;;
+    leg->SetHeader("Particle Species");
     for(Int_t is=0; is<AliPID::kSPECIES; is++){
       Int_t bin = is*AliTRDCalPID::kNMom+4;
       h1 = h2->ProjectionY("py", bin, bin);
@@ -862,18 +945,22 @@ void AliTRDpidChecker::GetRefFigure(Int_t ifig)
       h1->SetMarkerStyle(24);
       h1->SetMarkerColor(AliTRDCalPID::GetPartColor(is));
       h1->SetLineColor(AliTRDCalPID::GetPartColor(is));
-      h1->DrawClone(FIRST ? "e2" : "same e2");
+      h = (TH1F*)h1->DrawClone(FIRST ? "pc" : "same pc");
+      leg->AddEntry(h, Form("%s", AliTRDCalPID::GetPartName(is)), "pl");
       FIRST = kFALSE;
     }
+    if(FIRST) break;
+    leg->Draw();
     gPad->SetLogy(0);
     gPad->SetLogx(0);
     gPad->SetGridy();
     gPad->SetGridx();
-    break;
-  case 3:
+    return;
+  case kNClus:
     // save 2.0 GeV projection as reference
     FIRST = kTRUE;
-    h2 = (TH2F*)(fContainer->At(kNClus));
+    if(!(h2 = (TH2F*)(fContainer->At(kNClus)))) break;
+    leg->SetHeader("Particle Species");
     for(Int_t is=0; is<AliPID::kSPECIES; is++){
       Int_t bin = is*AliTRDCalPID::kNMom+4;
       h1 = h2->ProjectionY("py", bin, bin);
@@ -881,15 +968,42 @@ void AliTRDpidChecker::GetRefFigure(Int_t ifig)
       h1->SetMarkerStyle(24);
       h1->SetMarkerColor(AliTRDCalPID::GetPartColor(is));
       h1->SetLineColor(AliTRDCalPID::GetPartColor(is));
-      h1->DrawClone(FIRST ? "e2" : "same e2");
+      h = (TH1F*)h1->DrawClone(FIRST ? "pc" : "same pc");
+      leg->AddEntry(h, Form("%s", AliTRDCalPID::GetPartName(is)), "pl");
       FIRST = kFALSE;
     }
+    if(FIRST) break;
+    leg->Draw();
     gPad->SetLogy(0);
     gPad->SetLogx(0);
     gPad->SetGridy();
     gPad->SetGridx();
-    break;
+    return;
+  case kMomentum:
+  case kMomentumBin:
+    break; 
+  case kThresh:
+    if(!(g = (TGraphErrors*)fGraph->At(kLQ+3))) break;
+    if(!g->GetN()) break;
+    leg->SetHeader("PID Method");
+    g->Draw("apl");
+    g->GetHistogram()->GetXaxis()->SetTitle("p [GeV/c]");
+    g->GetHistogram()->GetXaxis()->SetRangeUser(.6, 10.5);
+    g->GetHistogram()->GetYaxis()->SetTitle("threshold");
+    leg->AddEntry(g, "2D LQ", "pl");
+    if(!(g = (TGraphErrors*)fGraph->At(kNN+3))) break;
+    g->Draw("pl");
+    leg->AddEntry(g, "NN", "pl");
+    if(!(g = (TGraphErrors*)fGraph->At(kESD+3))) break;
+    g->Draw("pl");
+    leg->AddEntry(g, "ESD", "pl");
+    leg->Draw();
+    gPad->SetLogx();
+    gPad->SetGridy();
+    gPad->SetGridx();
+    return;
   }
+  AliInfo(Form("Reference plot [%d] missing result", ifig));
 }
 
 //________________________________________________________________________
@@ -902,91 +1016,115 @@ Bool_t AliTRDpidChecker::PostProcess()
     Printf("ERROR: list not available");
     return kFALSE;
   }
-//   return kTRUE; // testing protection
-
-
-  // container for the pion efficiencies and the errors
-  Double_t  PionEffiLQ[AliTRDCalPID::kNMom], 
-            PionEffiErrorLQ[AliTRDCalPID::kNMom], 
-            EleEffiLQ[AliTRDCalPID::kNMom],
-            ThresholdLQ[AliTRDCalPID::kNMom];
+  if(!(fEfficiency = dynamic_cast<TObjArray *>(fContainer->At(kEfficiency)))){
+    AliError("Efficiency container missing.");
+    return 0x0;
+  }
 
-  Double_t  PionEffiNN[AliTRDCalPID::kNMom],
-            PionEffiErrorNN[AliTRDCalPID::kNMom],
-            EleEffiNN[AliTRDCalPID::kNMom],
-            ThresholdNN[AliTRDCalPID::kNMom];
+  TGraphErrors *g = 0x0;
+  if(!fGraph){ 
+    fGraph = new TObjArray(6);
+    fGraph->SetOwner();
+
+    fGraph->AddAt(g = new TGraphErrors(), kLQ);
+    g->SetLineColor(kBlue);
+    g->SetMarkerColor(kBlue);
+    g->SetMarkerStyle(29);
+  
+    fGraph->AddAt(g = new TGraphErrors(), kNN);
+    g->SetLineColor(kRed);
+    g->SetMarkerColor(kRed);
+    g->SetMarkerStyle(29);
+  
+    fGraph -> AddAt(g = new TGraphErrors(), kESD);
+    g->SetLineColor(kGreen);
+    g->SetMarkerColor(kGreen);
+    g->SetMarkerStyle(29);
+
+    fGraph->AddAt(g = new TGraphErrors(), 3+kLQ);
+    g->SetLineColor(kBlue);
+    g->SetMarkerColor(kBlue);
+    g->SetMarkerStyle(29);
+  
+    fGraph->AddAt(g = new TGraphErrors(), 3+kNN);
+    g->SetLineColor(kRed);
+    g->SetMarkerColor(kRed);
+    g->SetMarkerStyle(29);
+  
+    fGraph -> AddAt(g = new TGraphErrors(), 3+kESD);
+    g->SetLineColor(kGreen);
+    g->SetMarkerColor(kGreen);
+    g->SetMarkerStyle(29);
+  }
 
   Float_t mom = 0.;
-
   TH1D *Histo1=0x0, *Histo2=0x0;
 
-  TH2F *hPIDLQ=0x0, *hPIDNN=0x0;
-  hPIDLQ = (TH2F*)fContainer->At(kLQlikelihood);
-  hPIDNN = (TH2F*)fContainer->At(kNNlikelihood);
-
   // calculate the pion efficiencies and the errors for 90% electron efficiency (2-dim LQ)
+  TH2F *hPIDLQ = (TH2F*)fEfficiency->At(kLQ);
   for(Int_t iMom = 0; iMom < AliTRDCalPID::kNMom; iMom++){
-
-    AliTRDpidUtil *util = new AliTRDpidUtil();
     mom = AliTRDCalPID::GetMomentum(iMom);
 
     Histo1 = hPIDLQ -> ProjectionY("LQ_ele",AliTRDCalPID::kNMom*AliPID::kElectron+iMom+1,AliTRDCalPID::kNMom*AliPID::kElectron+iMom+1);
     Histo2 = hPIDLQ -> ProjectionY("LQ_pio",AliTRDCalPID::kNMom*AliPID::kPion+iMom+1,AliTRDCalPID::kNMom*AliPID::kPion+iMom+1);
 
-    util -> CalculatePionEffi(Histo1, Histo2);
+    if(!fUtil->CalculatePionEffi(Histo1, Histo2)) continue;
 
-    PionEffiLQ[iMom] = util -> GetPionEfficiency();
-    PionEffiErrorLQ[iMom] = util -> GetError();
-    EleEffiLQ[iMom] = util -> GetCalcElectronEfficiency();
-    ThresholdLQ[iMom] = util -> GetThreshold();
+    g = (TGraphErrors*)fGraph->At(kLQ);
+    g->SetPoint(iMom, mom, fUtil->GetPionEfficiency());
+    g->SetPointError(iMom, 0., fUtil->GetError());
+    g = (TGraphErrors*)fGraph->At(3 + kLQ);
+    g->SetPoint(iMom, mom, fUtil->GetThreshold());
+    g->SetPointError(iMom, 0., 0.);
 
-    if(fDebugLevel>=1) Printf("Pion Efficiency for 2-dim LQ is : %f +/- %f\n\n", PionEffiLQ[iMom], PionEffiErrorLQ[iMom]);
-    util -> Delete();
+    if(fDebugLevel>=2) Printf("Pion Efficiency for 2-dim LQ is : %f +/- %f\n\n", fUtil->GetPionEfficiency(), fUtil->GetError());
   }
   
 
-
   // calculate the pion efficiencies and the errors for 90% electron efficiency (NN)
+  TH2F *hPIDNN = (TH2F*)fEfficiency->At(kNN);
   for(Int_t iMom = 0; iMom < AliTRDCalPID::kNMom; iMom++){
-
-    AliTRDpidUtil *util = new AliTRDpidUtil();
     mom = AliTRDCalPID::GetMomentum(iMom);
 
     Histo1 = hPIDNN -> ProjectionY("NN_ele",AliTRDCalPID::kNMom*AliPID::kElectron+iMom+1,AliTRDCalPID::kNMom*AliPID::kElectron+iMom+1);
     Histo2 = hPIDNN -> ProjectionY("NN_pio",AliTRDCalPID::kNMom*AliPID::kPion+iMom+1,AliTRDCalPID::kNMom*AliPID::kPion+iMom+1);
 
-    util -> CalculatePionEffi(Histo1, Histo2);
+    if(!fUtil -> CalculatePionEffi(Histo1, Histo2)) continue;
 
-    PionEffiNN[iMom] = util -> GetPionEfficiency();
-    PionEffiErrorNN[iMom] = util -> GetError();
-    EleEffiNN[iMom] = util -> GetCalcElectronEfficiency();
-    ThresholdNN[iMom] = util -> GetThreshold();
+    g = (TGraphErrors*)fGraph->At(kNN);
+    g->SetPoint(iMom, mom, fUtil->GetPionEfficiency());
+    g->SetPointError(iMom, 0., fUtil->GetError());
+    g = (TGraphErrors*)fGraph->At(3+kNN);
+    g->SetPoint(iMom, mom, fUtil->GetThreshold());
+    g->SetPointError(iMom, 0., 0.);
 
-    if(fDebugLevel>=1) Printf("Pion Efficiency for NN is : %f +/- %f\n\n", PionEffiNN[iMom], PionEffiErrorNN[iMom]);
-
-    util -> Delete();
+    if(fDebugLevel>=2) Printf("Pion Efficiency for NN is : %f +/- %f\n\n", fUtil->GetPionEfficiency(), fUtil->GetError());
   }
-  
 
-  // create TGraph to plot the pion efficiencies
-  TGraphErrors *gEffisLQ=0x0, *gEffisNN=0x0;
-  gEffisLQ = (TGraphErrors*)fContainer->At(kGraphLQ);
-  gEffisNN = (TGraphErrors*)fContainer->At(kGraphNN);
 
+  // calculate the pion efficiencies and the errors for 90% electron efficiency (ESD)
+  TH2F *hPIDESD = (TH2F*)fEfficiency->At(kESD);
+  for(Int_t iMom = 0; iMom < AliTRDCalPID::kNMom; iMom++){
+    mom = AliTRDCalPID::GetMomentum(iMom);
+
+    Histo1 = hPIDESD -> ProjectionY("NN_ele",AliTRDCalPID::kNMom*AliPID::kElectron+iMom+1,AliTRDCalPID::kNMom*AliPID::kElectron+iMom+1);
+    Histo2 = hPIDESD -> ProjectionY("NN_pio",AliTRDCalPID::kNMom*AliPID::kPion+iMom+1,AliTRDCalPID::kNMom*AliPID::kPion+iMom+1);
 
-  for(Int_t iBin = 0; iBin < AliTRDCalPID::kNMom; iBin++){
+    if(!fUtil->CalculatePionEffi(Histo1, Histo2)) continue;
 
-    Float_t momentum = AliTRDCalPID::GetMomentum(iBin);
-    gEffisLQ->SetPoint(iBin, momentum, PionEffiLQ[iBin]);
-    gEffisLQ->SetPointError(iBin, 0., PionEffiErrorLQ[iBin]);
+    g = (TGraphErrors*)fGraph->At(kESD);
+    g->SetPoint(iMom, mom, fUtil->GetPionEfficiency());
+    g->SetPointError(iMom, 0., fUtil->GetError());
+    g = (TGraphErrors*)fGraph->At(3+kESD);
+    g->SetPoint(iMom, mom, fUtil->GetThreshold());
+    g->SetPointError(iMom, 0., 0.);
 
-    gEffisNN->SetPoint(iBin, momentum, PionEffiNN[iBin]);
-    gEffisNN->SetPointError(iBin, 0., PionEffiErrorNN[iBin]);
+    if(fDebugLevel>=2) Printf("Pion Efficiency for ESD is : %f +/- %f\n\n", fUtil->GetPionEfficiency(), fUtil->GetError());
   }
 
+  fNRefFigures = 8;
 
-  fNRefFigures = 4/*1*/;
-  return kTRUE; // testing protection
+  return kTRUE;
 }
 
 

diff --git a/TRD/qaRec/AliTRDpidChecker.h b/TRD/qaRec/AliTRDpidChecker.h
index 31706048393fee41e78687651ce066b89b4256ef..e26bcd6f67dd677294a57dc0efeb5b5f9a1bb705 100644 (file)
--- a/TRD/qaRec/AliTRDpidChecker.h
+++ b/TRD/qaRec/AliTRDpidChecker.h
@@ -17,24 +17,23 @@ class AliTRDReconstructor;
 class AliTRDpidUtil;
 class AliTRDpidChecker : public AliTRDrecoTask 
 {
-
+  // Plots registered for this task
   enum{
-    kLQlikelihood    = 0     // place for 2-dim LQ electron likelihood distributions
-    ,kNNlikelihood   = 1     // place for NN electron likelihood distributions
-    ,kdEdx           = 2     // place for the dE/dx spectra
-    ,kdEdxSlice      = 3     // place for the dE/dx spectra
-    ,kPH             = 4     // place for pulse height spectra
-    ,kNClus          = 5     // place for the number of clusters per track
-    ,kMomentum       = 6     // place for the momentum distribution
-    ,kMomentumBin    = 7     // place for the momentum distribution
-    ,kGraphLQ        = 8     // place for the 2-dim LQ pion efficiencies
-    ,kGraphNN        = 9     // place for the NN pion efficiencies
+     kEfficiency     =  0     // pi Efficiency plot
+    ,kdEdx           =  1     // dE/dx spectra
+    ,kdEdxSlice      =  2     // dE/dx spectra
+    ,kPH             =  3     // pulse height spectra
+    ,kNClus          =  4     //  number of clusters per track
+    ,kMomentum       =  5     // momentum distribution
+    ,kMomentumBin    =  6     // momentum distribution
+    ,kThresh         =  7     // threshold in efficiency
   };
-
-  enum{
-    kGraphStart = kGraphLQ
+  // PID methods
+  enum {
+     kLQ   = 0 // 2D likelihood method
+    ,kNN   = 1 // Neural network method
+    ,kESD  = 2 // ESD results - check offline
   };
-
 public:
   AliTRDpidChecker();
   virtual ~AliTRDpidChecker();
@@ -46,6 +45,7 @@ public:
 
   TH1 *PlotLQ(const AliTRDtrackV1 *track = 0x0);
   TH1 *PlotNN(const AliTRDtrackV1 *track = 0x0);
+  TH1 *PlotESD(const AliTRDtrackV1 *track = 0x0);
   TH1 *PlotdEdx(const AliTRDtrackV1 *track = 0x0);
   TH1 *PlotdEdxSlice(const AliTRDtrackV1 *track = 0x0);
   TH1 *PlotPH(const AliTRDtrackV1 *track = 0x0);
@@ -53,6 +53,7 @@ public:
   TH1 *PlotMom(const AliTRDtrackV1 *track = 0x0);
   TH1 *PlotMomBin(const AliTRDtrackV1 *track = 0x0);
 
+
   virtual TObjArray *Histos();
 
 private:
@@ -64,6 +65,8 @@ private:
   
   AliTRDReconstructor *fReconstructor;     //! reconstructor needed for recalculation the PID
   AliTRDpidUtil       *fUtil;              //! utility class for PID calculations
+  TObjArray           *fGraph;             //! array of graphs filled in PostProcess
+  TObjArray           *fEfficiency;        //! array of histograms with efficiency
 
   ClassDef(AliTRDpidChecker, 1); // TRD PID checker
 };

diff --git a/TRD/qaRec/AliTRDtrackInfo/AliTRDtrackInfo.cxx b/TRD/qaRec/AliTRDtrackInfo/AliTRDtrackInfo.cxx
index 4205a7606b0821e0f15fae05026f0c5cda0ca266..25bdbfef14585701405051c0738c78d69130901b 100644 (file)
--- a/TRD/qaRec/AliTRDtrackInfo/AliTRDtrackInfo.cxx
+++ b/TRD/qaRec/AliTRDtrackInfo/AliTRDtrackInfo.cxx
@@ -253,7 +253,7 @@ void AliTRDtrackInfo::Delete(const Option_t *)
 }
 
 //___________________________________________________
-void AliTRDtrackInfo::SetTRDtrack(const AliTRDtrackV1 *track)
+void AliTRDtrackInfo::SetTrack(const AliTRDtrackV1 *track)
 {
   //
   // Set the TRD track

diff --git a/TRD/qaRec/AliTRDtrackInfo/AliTRDtrackInfo.h b/TRD/qaRec/AliTRDtrackInfo/AliTRDtrackInfo.h
index 4f26950a6d0ea7cbcc88628cfff8c6d96ff67458..e20f3653240d99f16e314eb8601ba4d556323ef0 100644 (file)
--- a/TRD/qaRec/AliTRDtrackInfo/AliTRDtrackInfo.h
+++ b/TRD/qaRec/AliTRDtrackInfo/AliTRDtrackInfo.h
@@ -43,7 +43,7 @@ public:
     UChar_t     GetPidQuality() const {return fTRDpidQuality;}
     Int_t       GetNSlices() const {return fTRDnSlices;}
     Double32_t* GetSliceIter() const {return fTRDslices;}
-    Double32_t* GetResponseIter() {return &fTRDr[0];}
+    const Double32_t* GetResponseIter() const {return &fTRDr[0];}
   protected:
     Int_t       fId;            // ESD track id
     ULong_t     fStatus;        // ESD track status
@@ -122,10 +122,10 @@ public:
   void               SetKinkIndex(Int_t kinkIndex) {fESD.fKinkIndex = kinkIndex;}
   void               SetTPCncls(UShort_t TPCncls) {fESD.fTPCncls = TPCncls;}
   void               SetTrackId(Int_t id) {fESD.fId = id;}
-  void               SetTRDtrack(const AliTRDtrackV1 *track);
-  void               SetPidQuality(UChar_t q) { fESD.fTRDpidQuality = q;}
+  void               SetTrack(const AliTRDtrackV1 *track);
+  void               SetESDpidQuality(UChar_t q) { fESD.fTRDpidQuality = q;}
   void               SetSlices(Int_t n, Double32_t*);
-  inline void        SetResponse(Double32_t *);
+  inline void        SetESDpid(Double_t *);
   
 private:
     enum{
@@ -150,9 +150,9 @@ inline void AliTRDtrackInfo::SetMC()
 }
 
 //________________________________________________________
-inline void AliTRDtrackInfo::SetResponse(Double32_t *r)
-{
-  memcpy(fESD.fTRDr, r, AliPID::kSPECIES*sizeof(Double32_t));
+inline void AliTRDtrackInfo::SetESDpid(Double_t *r)
+{ 
+  for(Int_t is = AliPID::kSPECIES; is--;) fESD.fTRDr[is] = r[is];
 }
 
 #endif

diff --git a/TRD/qaRec/AliTRDtrackInfoGen.cxx b/TRD/qaRec/AliTRDtrackInfoGen.cxx
index c47c07c4525e407b7e1c0ca84b785c089d130de6..ccc97a6b43077b5a9c62944c85ab4c7017f863aa 100644 (file)
--- a/TRD/qaRec/AliTRDtrackInfoGen.cxx
+++ b/TRD/qaRec/AliTRDtrackInfoGen.cxx
@@ -46,6 +46,7 @@
 #include "AliESDHeader.h"
 #include "AliESDtrack.h"
 #include "AliMCParticle.h"
+#include "AliPID.h"
 #include "AliStack.h"
 #include "AliTRDtrackV1.h"
 #include "AliTrackReference.h"
@@ -235,17 +236,6 @@ void AliTRDtrackInfoGen::Exec(Option_t *){
         fTrackInfo->AddTrackRef(ref);
         jref++;
       }
-      if(!fTrackInfo->GetNTrackRefs()){ 
-          //if(!esdTrack->GetNcls(2)) continue;
-  /*           printf("No TRD Track References in the Track [%d] II\n", itrk);
-            printf("Label = %d ITS[%d] TPC[%d] TRD[%d]\n", label, esdTrack->GetITSLabel(), esdTrack->GetTPCLabel(), esdTrack-  >GetTRDLabel());
-            Int_t kref = 0;
-            while(kref<nRefs){
-              ref = mcParticle->GetTrackReference(kref);
-              printf("\ttrackRef[%2d] @ %7.3f\n", kref, ref->LocalX());
-              kref++;
-            }*/
-      }
       if(fDebugLevel>=2) printf("NtrackRefs[%d(%d)]\n", fTrackInfo->GetNTrackRefs(), nRefs);
     } else {
       new (fTrackInfo) AliTRDtrackInfo();
@@ -255,6 +245,9 @@ void AliTRDtrackInfoGen::Exec(Option_t *){
     // copy some relevant info to TRD track info
     fTrackInfo->SetStatus(esdTrack->GetStatus());
     fTrackInfo->SetTrackId(esdTrack->GetID());
+    Double_t p[AliPID::kSPECIES]; esdTrack->GetTRDpid(p);
+    fTrackInfo->SetESDpid(p);
+    fTrackInfo->SetESDpidQuality(esdTrack->GetTRDpidQuality());
     fTrackInfo->SetLabel(label);
     fTrackInfo->SetNumberOfClustersRefit(esdTrack->GetNcls(2));
     // some other Informations which we may wish to store in order to find problematic cases
@@ -272,7 +265,7 @@ void AliTRDtrackInfoGen::Exec(Option_t *){
         if(!(track = dynamic_cast<AliTRDtrackV1*>(calObject))) break;
         nTRD++;
         if(fDebugLevel>=3) printf("TRD track OK\n");
-        fTrackInfo->SetTRDtrack(track);
+        fTrackInfo->SetTrack(track);
         break;
       }
       if(fDebugLevel>=2) printf("Ntracklets[%d]\n", fTrackInfo->GetNTracklets());