trend plots for DET and ESD performance tasks
authorabercuci <abercuci@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 8 Oct 2009 10:36:19 +0000 (10:36 +0000)
committerabercuci <abercuci@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 8 Oct 2009 10:36:19 +0000 (10:36 +0000)
TRD/qaRec/AliTRDcheckDET.cxx
TRD/qaRec/AliTRDcheckDET.h
TRD/qaRec/AliTRDcheckESD.cxx
TRD/qaRec/AliTRDcheckESD.h
TRD/qaRec/AliTRDresolution.cxx
TRD/qaRec/AliTRDresolution.h

index 8f2e69f148d50511bde9d99d0fb23a7102035a13..0e5e0b26e46f4372548c63f11299773825bd3898 100644 (file)
@@ -186,27 +186,38 @@ Bool_t AliTRDcheckDET::GetRefFigure(Int_t ifig){
   //
   gPad->SetLogy(0);
   gPad->SetLogx(0);
+  TH1 *h = 0x0;
   switch(ifig){
   case kNclustersTrack:
-    ((TH1F*)fContainer->FindObject("hNcls"))->Draw("pl");
+    (h=(TH1F*)fContainer->FindObject("hNcls"))->Draw("pl");
+    PutTrendValue("NClustersTrack", h->GetMean(), h->GetRMS());
     return kTRUE;
   case kNclustersTracklet:
-    ((TH1F*)fContainer->FindObject("hNclTls"))->Draw("pc");
+    (h =(TH1F*)fContainer->FindObject("hNclTls"))->Draw("pc");
+    PutTrendValue("NClustersTracklet", h->GetMean(), h->GetRMS());
     return kTRUE;
   case kNtrackletsTrack:
-    MakePlotNTracklets();
+    h=MakePlotNTracklets();
+    PutTrendValue("NTrackletsTracklet", h->GetMean(), h->GetRMS());
     return kTRUE;
   case kNtrackletsCross:
-    if(!MakeBarPlot((TH1F*)fContainer->FindObject("hNtlsCross"), kRed)) break;
+    h = (TH1F*)fContainer->FindObject("hNtlsCross");
+    if(!MakeBarPlot(h, kRed)) break;
+    PutTrendValue("NTrackletsCross", h->GetMean(), h->GetRMS());
     return kTRUE;
   case kNtrackletsFindable:
-    if(!MakeBarPlot((TH1F*)fContainer->FindObject("hNtlsFindable"), kGreen)) break;
+    h = (TH1F*)fContainer->FindObject("hNtlsFindable");
+    if(!MakeBarPlot(h, kGreen)) break;
+    PutTrendValue("NTrackletsFindable", h->GetMean(), h->GetRMS());
     return kTRUE;
   case kNtracksEvent:
-    ((TH1F*)fContainer->FindObject("hNtrks"))->Draw("pl");
+    (h = (TH1F*)fContainer->FindObject("hNtrks"))->Draw("pl");
+    PutTrendValue("NTracksEvent", h->GetMean(), h->GetRMS());
     return kTRUE;
   case kNtracksSector:
-    if(!MakeBarPlot((TH1F*)fContainer->FindObject("hNtrksSector"), kGreen)) break;
+    h = (TH1F*)fContainer->FindObject("hNtrksSector");
+    if(!MakeBarPlot(h, kGreen)) break;
+    PutTrendValue("NTracksSector", h->GetMean(2), h->GetRMS(2));
     return kTRUE;
   case kTrackStatus:
     ((TH1I *)fContainer->FindObject("hTrackStatus"))->Draw("c");
@@ -221,11 +232,13 @@ Bool_t AliTRDcheckDET::GetRefFigure(Int_t ifig){
     MakePlotPulseHeight();
     return kTRUE;
   case kChargeCluster:
-    ((TH1F*)fContainer->FindObject("hQcl"))->Draw("c");
+    (h = (TH1F*)fContainer->FindObject("hQcl"))->Draw("c");
     gPad->SetLogy(1);
+    PutTrendValue("ChargeCluster", h->GetMaximumBin(), h->GetRMS());
     return kTRUE;
   case kChargeTracklet:
-    ((TH1F*)fContainer->FindObject("hQtrklt"))->Draw("c");
+    (h=(TH1F*)fContainer->FindObject("hQtrklt"))->Draw("c");
+    PutTrendValue("ChargeTracklet", h->GetMaximumBin(), h->GetRMS());
     return kTRUE;
   case kNeventsTrigger:
     ((TH1F*)fContainer->FindObject("hEventsTrigger"))->Draw("");
@@ -975,7 +988,7 @@ void AliTRDcheckDET::GetDistanceToTracklet(Double_t *dist, AliTRDseedV1 *trackle
 
 
 //_______________________________________________________
-void AliTRDcheckDET::MakePlotChi2()
+TH1* AliTRDcheckDET::MakePlotChi2()
 {
 // Plot chi2/track normalized to number of degree of freedom 
 // (tracklets) and compare with the theoretical distribution.
@@ -986,9 +999,10 @@ void AliTRDcheckDET::MakePlotChi2()
   TF1 f("fChi2", "[0]*pow(x, [1]-1)*exp(-0.5*x)", 0., 50.);
   TLegend *leg = new TLegend(.7,.7,.95,.95);
   leg->SetBorderSize(1); leg->SetHeader("Tracklets per Track");
+  TH1D *h1 = 0x0;
   Bool_t kFIRST = kTRUE;
   for(Int_t il=1; il<=h2->GetNbinsX(); il++){
-    TH1D *h1 = h2->ProjectionY(Form("pyChi2%d", il), il, il);
+    h1 = h2->ProjectionY(Form("pyChi2%d", il), il, il);
     if(h1->Integral()<50) continue;
     h1->Scale(1./h1->Integral());
     h1->SetMarkerStyle(7);h1->SetMarkerColor(il);
@@ -1003,11 +1017,12 @@ void AliTRDcheckDET::MakePlotChi2()
   }
   leg->Draw();
   gPad->SetLogy();
+  return h1;
 }
 
 
 //________________________________________________________
-void AliTRDcheckDET::MakePlotNTracklets(){
+TH1* AliTRDcheckDET::MakePlotNTracklets(){
   //
   // Make nice bar plot of the number of tracklets in each method
   //
@@ -1047,10 +1062,11 @@ void AliTRDcheckDET::MakePlotNTracklets(){
   hSTA->Draw("bar1same"); leg->AddEntry(hSTA, "Stand Alone", "f");
   leg->Draw();
   gPad->Update();
+  return hCON;
 }
 
 //________________________________________________________
-void AliTRDcheckDET::MakePlotPulseHeight(){
+TH1* AliTRDcheckDET::MakePlotPulseHeight(){
   //
   // Create Plot of the Pluse Height Spectrum
   //
@@ -1082,6 +1098,7 @@ void AliTRDcheckDET::MakePlotPulseHeight(){
   axis->SetTextColor(kBlue);
   axis->SetTitle("x_{0}-x_{c} [cm]");
   axis->Draw();
+  return h1;
 }
 
 //________________________________________________________
index 68e66046f1e30a14a282847f9991e95922fbe861..7b5fbcc5567d15c9d3ae188645185aa3c53e331a 100644 (file)
@@ -73,9 +73,9 @@ private:
   AliTRDcheckDET(const AliTRDcheckDET &);
   AliTRDcheckDET& operator=(const AliTRDcheckDET &);
   void GetDistanceToTracklet(Double_t *dist, AliTRDseedV1 *tracklet, AliTRDcluster *c);
-  void MakePlotChi2();
-  void MakePlotNTracklets();
-  void MakePlotPulseHeight();
+  TH1* MakePlotChi2();
+  TH1* MakePlotNTracklets();
+  TH1* MakePlotPulseHeight();
   Bool_t MakeBarPlot(TH1 *histo, Int_t Color);
   AliTRDeventInfo *fEventInfo;         //! ESD Header
   TMap *fTriggerNames;                 //! Containing trigger class names
index f11c8f16cde75935c9df75f0523c3e8a7248b183..5e88ac16ac3c60d78e4b8c3b9294d8c5005cd769 100644 (file)
@@ -46,6 +46,7 @@ ClassImp(AliTRDcheckESD)
 const Int_t   AliTRDcheckESD::fgkNgraphs = 4;
 const Float_t AliTRDcheckESD::fgkxTPC = 290.;
 const Float_t AliTRDcheckESD::fgkxTOF = 365.;
+FILE* AliTRDcheckESD::fgFile = 0x0;
 
 //____________________________________________________________________
 AliTRDcheckESD::AliTRDcheckESD():
@@ -129,7 +130,11 @@ TGraphErrors* AliTRDcheckESD::GetGraph(Int_t id, Option_t *opt)
 
   TGraphErrors *g = 0x0;
   if((g = dynamic_cast<TGraphErrors*>(res->At(id)))){
-    if(kCLEAR) for(Int_t ip=g->GetN(); ip--;) g->RemovePoint(ip);
+    if(kCLEAR){ 
+      for(Int_t ip=g->GetN(); ip--;) g->RemovePoint(ip);
+    } else {
+      PutTrendValue(name[id], g->GetMean(2), g->GetRMS(2));
+    }
   } else {
     if(kBUILD){
       g = new TGraphErrors();
@@ -305,6 +310,16 @@ Bool_t AliTRDcheckESD::Load(const Char_t *filename, const Char_t *name)
   return kTRUE;
 }
 
+//_______________________________________________________
+Bool_t AliTRDcheckESD::PutTrendValue(const Char_t *name, Double_t val, Double_t err)
+{
+  if(!fgFile){
+    fgFile = fopen("TRD.Performance.txt", "at");
+  }
+  fprintf(fgFile, "%s_%s %f %f\n", GetName(), name, val, err);
+  return kTRUE;
+}
+
 //____________________________________________________________________
 void AliTRDcheckESD::Terminate(Option_t *)
 {
index 4f5a67b087f44edf76b4dc05a707293f785c7410..95dc9a732eb7eeb96fcc53d2f774e44a49f72422 100644 (file)
@@ -51,6 +51,7 @@ public:
   TObjArray*    Histos();
   Bool_t        Load(const Char_t *fn, const Char_t *name=0x0);
   void          SetMC(Bool_t mc = kTRUE) { mc ? SETBIT(fStatus, kMC) : CLRBIT(fStatus, kMC);}
+  Bool_t        PutTrendValue(const Char_t *name, Double_t val, Double_t err);
   void          Terminate(Option_t *);
 
   static const Int_t   fgkNgraphs;
@@ -67,6 +68,7 @@ private:
   AliESDEvent      *fESD;              // ESD event
   AliMCEvent       *fMC;               // MC event
   TObjArray        *fHistos;           // QA histos
-  ClassDef(AliTRDcheckESD, 1)          // user oriented TRD analysis based on ESD-MC data
+  static FILE *fgFile;                 //! trend file streamer
+  ClassDef(AliTRDcheckESD, 2)          // user oriented TRD analysis based on ESD-MC data
 };
 #endif
index be7e2924f5ded399f54995dacf8f49c3ee89d822..2bba303c5ff729d234ca7a911b9d537b1654196b 100644 (file)
@@ -108,63 +108,62 @@ Char_t* AliTRDresolution::fPerformanceName[kNhistos] = {
     ,"TOF/HMPID2MC"
     ,"TRD2MC"
 };
-//Int_t AliTRDresolution::fNPlots = 0; 
-Char_t *AliTRDresolution::fAxTitle[46][3] = {
+Char_t *AliTRDresolution::fAxTitle[46][4] = {
   // Charge
-  {"x [cm]", "I_{mpv}", "x/x_{0}"}
- ,{"x/x_{0}", "#delta I/I_{mpv}", "x[cm]"}
+  {"Impv", "x [cm]", "I_{mpv}", "x/x_{0}"}
+ ,{"dI/Impv", "x/x_{0}", "#delta I/I_{mpv}", "x[cm]"}
   // Clusters to Kalman
- ,{"tg(#phi)", "#mu_{y}^{cl} [#mum]", "#sigma_{y}^{cl} [#mum]"}
- ,{"tg(#phi)", "PULL: #mu_{y}^{cl}", "PULL: #sigma_{y}^{cl}"}
+ ,{"Pos", "tg(#phi)", "#mu_{y}^{cl} [#mum]", "#sigma_{y}^{cl} [#mum]"}
+ ,{"Pulls", "tg(#phi)", "PULL: #mu_{y}^{cl}", "PULL: #sigma_{y}^{cl}"}
   // TRD tracklet to Kalman fit
- ,{"tg(#phi)", "#mu_{y}^{trklt} [#mum]", "#sigma_{y}^{trklt} [#mum]"}
- ,{"tg(#phi)", "PULL: #mu_{y}^{trklt}", "PULL: #sigma_{y}^{trklt}"}
- ,{"tg(#theta)", "#mu_{z}^{trklt} [#mum]", "#sigma_{z}^{trklt} [#mum]"}
- ,{"tg(#theta)", "PULL: #mu_{z}^{trklt}", "PULL: #sigma_{z}^{trklt}"}
- ,{"tg(#phi)", "#mu_{#phi}^{trklt} [mrad]", "#sigma_{#phi}^{trklt} [mrad]"}
+ ,{"PosY", "tg(#phi)", "#mu_{y}^{trklt} [#mum]", "#sigma_{y}^{trklt} [#mum]"}
+ ,{"PullsY", "tg(#phi)", "PULL: #mu_{y}^{trklt}", "PULL: #sigma_{y}^{trklt}"}
+ ,{"PosZ", "tg(#theta)", "#mu_{z}^{trklt} [#mum]", "#sigma_{z}^{trklt} [#mum]"}
+ ,{"PullsZ", "tg(#theta)", "PULL: #mu_{z}^{trklt}", "PULL: #sigma_{z}^{trklt}"}
+ ,{"Phi", "tg(#phi)", "#mu_{#phi}^{trklt} [mrad]", "#sigma_{#phi}^{trklt} [mrad]"}
   // TPC track 2 first TRD tracklet
- ,{"tg(#phi)", "#mu_{y}^{TPC trklt} [#mum]", "#sigma_{y}^{TPC trklt} [#mum]"}
- ,{"tg(#phi)", "PULL: #mu_{y}^{TPC trklt}", "PULL: #sigma_{y}^{TPC trklt}"}
- ,{"tg(#theta)", "#mu_{z}^{TPC trklt} [#mum]", "#sigma_{z}^{TPC trklt} [#mum]"}
- ,{"tg(#theta)", "PULL: #mu_{z}^{TPC trklt}", "PULL: #sigma_{z}^{TPC trklt}"}
- ,{"tg(#phi)", "#mu_{#phi}^{TPC trklt} [mrad]", "#sigma_{#phi}^{TPC trklt} [mrad]"}
+ ,{"PosY", "tg(#phi)", "#mu_{y}^{TPC trklt} [#mum]", "#sigma_{y}^{TPC trklt} [#mum]"}
+ ,{"PullsY", "tg(#phi)", "PULL: #mu_{y}^{TPC trklt}", "PULL: #sigma_{y}^{TPC trklt}"}
+ ,{"PosZ", "tg(#theta)", "#mu_{z}^{TPC trklt} [#mum]", "#sigma_{z}^{TPC trklt} [#mum]"}
+ ,{"PullsZ", "tg(#theta)", "PULL: #mu_{z}^{TPC trklt}", "PULL: #sigma_{z}^{TPC trklt}"}
+ ,{"Phi", "tg(#phi)", "#mu_{#phi}^{TPC trklt} [mrad]", "#sigma_{#phi}^{TPC trklt} [mrad]"}
   // MC cluster
- ,{"tg(#phi)", "MC: #mu_{y}^{cl} [#mum]", "MC: #sigma_{y}^{cl} [#mum]"}
- ,{"tg(#phi)", "MC PULL: #mu_{y}^{cl}", "MC PULL: #sigma_{y}^{cl}"}
+ ,{"Pos", "tg(#phi)", "MC: #mu_{y}^{cl} [#mum]", "MC: #sigma_{y}^{cl} [#mum]"}
+ ,{"Pulls", "tg(#phi)", "MC PULL: #mu_{y}^{cl}", "MC PULL: #sigma_{y}^{cl}"}
   // MC tracklet
- ,{"tg(#phi)", "MC: #mu_{y}^{trklt} [#mum]", "MC: #sigma_{y}^{trklt} [#mum]"}
- ,{"tg(#phi)", "MC PULL: #mu_{y}^{trklt}", "MC PULL: #sigma_{y}^{trklt}"}
- ,{"tg(#theta)", "MC: #mu_{z}^{trklt} [#mum]", "MC: #sigma_{z}^{trklt} [#mum]"}
- ,{"tg(#theta)", "MC PULL: #mu_{z}^{trklt}", "MC PULL: #sigma_{z}^{trklt}"}
- ,{"tg(#phi)", "MC: #mu_{#phi}^{trklt} [mrad]", "MC: #sigma_{#phi}^{trklt} [mrad]"}
+ ,{"PosY", "tg(#phi)", "MC: #mu_{y}^{trklt} [#mum]", "MC: #sigma_{y}^{trklt} [#mum]"}
+ ,{"PullsY", "tg(#phi)", "MC PULL: #mu_{y}^{trklt}", "MC PULL: #sigma_{y}^{trklt}"}
+ ,{"PosZ", "tg(#theta)", "MC: #mu_{z}^{trklt} [#mum]", "MC: #sigma_{z}^{trklt} [#mum]"}
+ ,{"PullsZ", "tg(#theta)", "MC PULL: #mu_{z}^{trklt}", "MC PULL: #sigma_{z}^{trklt}"}
+ ,{"Phi", "tg(#phi)", "MC: #mu_{#phi}^{trklt} [mrad]", "MC: #sigma_{#phi}^{trklt} [mrad]"}
   // MC track TPC
- ,{"tg(#phi)", "MC: #mu_{y}^{TPC} [#mum]", "MC: #sigma_{y}^{TPC} [#mum]"}
- ,{"tg(#phi)", "MC PULL: #mu_{y}^{TPC}", "MC PULL: #sigma_{y}^{TPC}"}
- ,{"tg(#theta)", "MC: #mu_{z}^{TPC} [#mum]", "MC: #sigma_{z}^{TPC} [#mum]"}
- ,{"tg(#theta)", "MC PULL: #mu_{z}^{TPC}", "MC PULL: #sigma_{z}^{TPC}"}
- ,{"tg(#phi)", "MC: #mu_{#phi}^{TPC} [mrad]", "MC: #sigma_{#phi}^{TPC} [mrad]"}
- ,{"tg(#phi)", "MC PULL: #mu_{snp}^{TPC}", "MC PULL: #sigma_{snp}^{TPC}"}
- ,{"tg(#theta)", "MC: #mu_{#theta}^{TPC} [mrad]", "MC: #sigma_{#theta}^{TPC} [mrad]"}
- ,{"tg(#theta)", "MC PULL: #mu_{tgl}^{TPC}", "MC PULL: #sigma_{tgl}^{TPC}"}
- ,{"p_{t}^{MC} [GeV/c]", "MC: #mu^{TPC}(#Deltap_{t}/p_{t}^{MC}) [%]", "MC: #sigma^{TPC}(#Deltap_{t}/p_{t}^{MC}) [%]"}
- ,{"1/p_{t}^{MC} [c/GeV]", "MC PULL: #mu_{1/p_{t}}^{TPC}", "MC PULL: #sigma_{1/p_{t}}^{TPC}"}
- ,{"p^{MC} [GeV/c]", "MC: #mu^{TPC}(#Deltap/p^{MC}) [%]", "MC: #sigma^{TPC}(#Deltap/p^{MC}) [%]"}
- ,{"p^{MC} [GeV/c]", "MC PULL: #mu^{TPC}(#Deltap/#sigma_{p})", "MC PULL: #sigma^{TPC}(#Deltap/#sigma_{p})"}
+ ,{"PosY", "tg(#phi)", "MC: #mu_{y}^{TPC} [#mum]", "MC: #sigma_{y}^{TPC} [#mum]"}
+ ,{"PullsY", "tg(#phi)", "MC PULL: #mu_{y}^{TPC}", "MC PULL: #sigma_{y}^{TPC}"}
+ ,{"PosZ", "tg(#theta)", "MC: #mu_{z}^{TPC} [#mum]", "MC: #sigma_{z}^{TPC} [#mum]"}
+ ,{"PullsZ", "tg(#theta)", "MC PULL: #mu_{z}^{TPC}", "MC PULL: #sigma_{z}^{TPC}"}
+ ,{"Phi", "tg(#phi)", "MC: #mu_{#phi}^{TPC} [mrad]", "MC: #sigma_{#phi}^{TPC} [mrad]"}
+ ,{"PullsSNP", "tg(#phi)", "MC PULL: #mu_{snp}^{TPC}", "MC PULL: #sigma_{snp}^{TPC}"}
+ ,{"Theta", "tg(#theta)", "MC: #mu_{#theta}^{TPC} [mrad]", "MC: #sigma_{#theta}^{TPC} [mrad]"}
+ ,{"PullsTGL", "tg(#theta)", "MC PULL: #mu_{tgl}^{TPC}", "MC PULL: #sigma_{tgl}^{TPC}"}
+ ,{"Pt", "p_{t}^{MC} [GeV/c]", "MC: #mu^{TPC}(#Deltap_{t}/p_{t}^{MC}) [%]", "MC: #sigma^{TPC}(#Deltap_{t}/p_{t}^{MC}) [%]"}
+ ,{"Pulls1Pt", "1/p_{t}^{MC} [c/GeV]", "MC PULL: #mu_{1/p_{t}}^{TPC}", "MC PULL: #sigma_{1/p_{t}}^{TPC}"}
+ ,{"P", "p^{MC} [GeV/c]", "MC: #mu^{TPC}(#Deltap/p^{MC}) [%]", "MC: #sigma^{TPC}(#Deltap/p^{MC}) [%]"}
+ ,{"PullsP", "p^{MC} [GeV/c]", "MC PULL: #mu^{TPC}(#Deltap/#sigma_{p})", "MC PULL: #sigma^{TPC}(#Deltap/#sigma_{p})"}
   // MC track TOF
- ,{"tg(#theta)", "MC: #mu_{z}^{TOF} [#mum]", "MC: #sigma_{z}^{TOF} [#mum]"}
- ,{"tg(#theta)", "MC PULL: #mu_{z}^{TOF}", "MC PULL: #sigma_{z}^{TOF}"}
+ ,{"PosZ", "tg(#theta)", "MC: #mu_{z}^{TOF} [#mum]", "MC: #sigma_{z}^{TOF} [#mum]"}
+ ,{"PullsZ", "tg(#theta)", "MC PULL: #mu_{z}^{TOF}", "MC PULL: #sigma_{z}^{TOF}"}
   // MC track in TRD
- ,{"tg(#phi)", "MC: #mu_{y}^{Trk} [#mum]", "MC: #sigma_{y}^{Trk} [#mum]"}
- ,{"tg(#phi)", "MC PULL: #mu_{y}^{Trk}", "MC PULL: #sigma_{y}^{Trk}"}
- ,{"tg(#theta)", "MC: #mu_{z}^{Trk} [#mum]", "MC: #sigma_{z}^{Trk} [#mum]"}
- ,{"tg(#theta)", "MC PULL: #mu_{z}^{Trk}", "MC PULL: #sigma_{z}^{Trk}"}
- ,{"tg(#phi)", "MC: #mu_{#phi}^{Trk} [mrad]", "MC: #sigma_{#phi}^{Trk} [mrad]"}
- ,{"tg(#phi)", "MC PULL: #mu_{snp}^{Trk}", "MC PULL: #sigma_{snp}^{Trk}"}
- ,{"tg(#theta)", "MC: #mu_{#theta}^{Trk} [mrad]", "MC: #sigma_{#theta}^{Trk} [mrad]"}
- ,{"tg(#theta)", "MC PULL: #mu_{tgl}^{Trk}", "MC PULL: #sigma_{tgl}^{Trk}"}
- ,{"p_{t}^{MC} [GeV/c]", "MC: #mu^{Trk}(#Deltap_{t}/p_{t}^{MC}) [%]", "MC: #sigma^{Trk}(#Deltap_{t}/p_{t}^{MC}) [%]"}
- ,{"1/p_{t}^{MC} [c/GeV]", "MC PULL: #mu_{1/p_{t}}^{Trk}", "MC PULL: #sigma_{1/p_{t}}^{Trk}"}
- ,{"p^{MC} [GeV/c]", "MC: #mu^{Trk}(#Deltap/p^{MC}) [%]", "MC: #sigma^{Trk}(#Deltap/p^{MC}) [%]"}
+ ,{"PosY", "tg(#phi)", "MC: #mu_{y}^{Trk} [#mum]", "MC: #sigma_{y}^{Trk} [#mum]"}
+ ,{"PullsY", "tg(#phi)", "MC PULL: #mu_{y}^{Trk}", "MC PULL: #sigma_{y}^{Trk}"}
+ ,{"PosZ", "tg(#theta)", "MC: #mu_{z}^{Trk} [#mum]", "MC: #sigma_{z}^{Trk} [#mum]"}
+ ,{"PullsZ", "tg(#theta)", "MC PULL: #mu_{z}^{Trk}", "MC PULL: #sigma_{z}^{Trk}"}
+ ,{"Phi", "tg(#phi)", "MC: #mu_{#phi}^{Trk} [mrad]", "MC: #sigma_{#phi}^{Trk} [mrad]"}
+ ,{"PullsSNP", "tg(#phi)", "MC PULL: #mu_{snp}^{Trk}", "MC PULL: #sigma_{snp}^{Trk}"}
+ ,{"Theta", "tg(#theta)", "MC: #mu_{#theta}^{Trk} [mrad]", "MC: #sigma_{#theta}^{Trk} [mrad]"}
+ ,{"PullsTGL", "tg(#theta)", "MC PULL: #mu_{tgl}^{Trk}", "MC PULL: #sigma_{tgl}^{Trk}"}
+ ,{"Pt", "p_{t}^{MC} [GeV/c]", "MC: #mu^{Trk}(#Deltap_{t}/p_{t}^{MC}) [%]", "MC: #sigma^{Trk}(#Deltap_{t}/p_{t}^{MC}) [%]"}
+ ,{"Pulls1Pt", "1/p_{t}^{MC} [c/GeV]", "MC PULL: #mu_{1/p_{t}}^{Trk}", "MC PULL: #sigma_{1/p_{t}}^{Trk}"}
+ ,{"P", "p^{MC} [GeV/c]", "MC: #mu^{Trk}(#Deltap/p^{MC}) [%]", "MC: #sigma^{Trk}(#Deltap/p^{MC}) [%]"}
 };
 
 //________________________________________________________
@@ -1803,35 +1802,37 @@ Bool_t AliTRDresolution::GetGraphPlot(Float_t *bb, ETRDresolutionPlot ip, Int_t
   if(!gs) return kFALSE;
   gs->Draw("apl"); gm->Draw("pl");
 
-  PutTrendValue(Form("%s_[%d]M", fPerformanceName[ip], idx), gm->GetMean(2), gm->GetRMS(2));
-  gs->Sort(&TGraph::CompareY); Int_t n = gs->GetN();
-  PutTrendValue(Form("%s_[%d]Sm", fPerformanceName[ip], idx), gs->GetY()[0], 0.);
-  PutTrendValue(Form("%s_[%d]SM", fPerformanceName[ip], idx), gs->GetY()[n-1], 0.);
-
-  // axis titles look up
+  // titles look up
   Int_t nref = 0;
   for(Int_t jp=0; jp<(Int_t)ip; jp++) nref+=fNElements[jp];
   UChar_t jdx = idx<0?0:idx;
   for(Int_t jc=0; jc<TMath::Min(jdx,fNElements[ip]-1); jc++) nref++;
   Char_t **at = fAxTitle[nref];
 
+  PutTrendValue(Form("%s_%sMean", fPerformanceName[ip], at[0]), gm->GetMean(2), gm->GetRMS(2));
+  gs->Sort(&TGraph::CompareY); Int_t n = gs->GetN();
+  PutTrendValue(Form("%s_%sSigMin", fPerformanceName[ip], at[0]), gs->GetY()[0], 0.);
+  PutTrendValue(Form("%s_%sSigMax", fPerformanceName[ip], at[0]), gs->GetY()[n-1], 0.);
+  gs->Sort(&TGraph::CompareX); 
+  
+
   // axis range
   TAxis *ax = 0x0;
   ax = gs->GetHistogram()->GetXaxis();
   ax->SetRangeUser(bb[0], bb[2]);
-  ax->SetTitle(*at);ax->CenterTitle();
+  ax->SetTitle(at[1]);ax->CenterTitle();
 
   ax = gs->GetHistogram()->GetYaxis();
   ax->SetRangeUser(bb[1], bb[3]);
   ax->SetTitleOffset(1.1);
-  ax->SetTitle(*(++at));ax->CenterTitle();
+  ax->SetTitle(at[2]);ax->CenterTitle();
 
   TGaxis *gax = 0x0;
   gax = new TGaxis(bb[2], bb[1], bb[2], bb[3], bb[1], bb[3], 510, "+U");
   gax->SetLineColor(kRed);gax->SetLineWidth(2);gax->SetTextColor(kRed);
   //gax->SetVertical();
   gax->CenterTitle(); gax->SetTitleOffset(.7);
-  gax->SetTitle(*(++at)); gax->Draw();
+  gax->SetTitle(at[3]); gax->Draw();
 
   // bounding box
   TBox *b = new TBox(-.15, bb[1], .15, bb[3]);
index c8e42a973bc2bb41777357f4693d69898d4502e6..e8ad8620fd2c2e7400e76b20d8dcaf31c7b35e9c 100644 (file)
@@ -87,7 +87,7 @@ private:
   UChar_t             fIdxPlot;         //! plot counter (internal)
   static Char_t       *fPerformanceName[kNhistos]; // name of performance plot
   static UChar_t      fNElements[kNhistos]; // number of componets per task
-  static Char_t       *fAxTitle[46][3]; // axis title for all ref histos
+  static Char_t       *fAxTitle[46][4]; // Title for all ref histos
   AliTRDReconstructor *fReconstructor;  //! local reconstructor
   AliTRDgeometry      *fGeo;            //! TRD geometry
   TObjArray           *fGraphS;         //! result holder - sigma values