Prototype of the QA analysis mini-train. It uses AliAnalysisTaskCosmic from PWG1...

diff --git a/PWG1/cosmic/AliAnalysisTaskCosmic.cxx b/PWG1/cosmic/AliAnalysisTaskCosmic.cxx
new file mode 100644 (file)
index 0000000..ea9f7f3
--- /dev/null
+++ b/PWG1/cosmic/AliAnalysisTaskCosmic.cxx
@@ -0,0 +1,421 @@
+#include "TChain.h"
+#include "TTree.h"
+#include "TH1F.h"
+#include "TH2F.h"
+#include "TProfile.h"
+#include "TList.h"
+#include "TTree.h"
+#include "TParticle.h"
+#include "TParticlePDG.h"
+
+
+#include "AliESDEvent.h"
+#include "AliESDtrack.h"
+#include "AliAnalysisTaskCosmic.h"
+#include "AliESDInputHandler.h"
+
+ClassImp(AliAnalysisTaskCosmic)
+
+//________________________________________________________________________
+AliAnalysisTaskCosmic::AliAnalysisTaskCosmic(const char *name) 
+    : AliAnalysisTaskSE(name),
+      fHists(0),
+      fhDZvsZ(0),
+      fhDZvsPhi(0),
+      fhCh1Ch2(0),
+      fhPh1Ph2(0),
+      fhCl1Cl2G(0),
+      fhCl1Cl2B(0)
+{
+  //
+  // Constructor
+  //
+    for (Int_t i = 0; i < 6; i++) {
+       fhPt[i]      = 0;
+       fhTheta[i]   = 0;
+       fhPhi[i]     = 0;
+       fhDPhi[i]    = 0;
+       fhDTheta[i]  = 0;
+       fhDZ[i]      = 0;
+       fhDX[i]      = 0;
+       fhDY[i]      = 0;
+       fhDPt[i]     = 0;
+       fhD1ovPt[i]  = 0;
+       fpDPt[i]     = 0;
+       fhDPtovPt[i] = 0;
+       fpDPtS[i]    = 0;
+    }
+    
+  DefineOutput(1,  TList::Class());
+}
+
+
+//________________________________________________________________________
+void AliAnalysisTaskCosmic::UserCreateOutputObjects()
+{
+  // Create histograms
+  // Called once
+    TString ext[6] = {"PC", "NC", "PZ", "NZ", "_Good", "_Bad"};
+    
+    char name[12];
+    
+    fHists = new TList();
+
+    for (Int_t i = 0; i < 6; i++) {
+       // Pt
+       sprintf(name, "fhPt%2s", ext[i].Data());
+       fhPt[i]   = new TH1F(name,   " pT distribution",        800, 0., 200.);
+       fhPt[i]->SetXTitle("p_{T} [Gev]");
+       // Phi
+       sprintf(name, "fhPhi%2s", ext[i].Data());
+       fhPhi[i]   = new TH1F(name,   "Phi distribution",        62,  0., 2. * TMath::Pi());
+       fhPhi[i]->SetXTitle("#phi [rad]");
+       // Theta
+       sprintf(name, "fhTheta%2s", ext[i].Data());
+       fhTheta[i]   = new TH1F(name,   "Theta distribution",    62,  0., TMath::Pi());    
+       fhTheta[i]->SetXTitle("#theta [rad]");
+       // Delta Phi
+       sprintf(name, "fhDPhi%2s", ext[i].Data());
+       fhDPhi[i]   = new TH1F(name,   "DeltaPhi distribution",        320, -0.4, 0.4);
+       fhDPhi[i]->SetXTitle("#Delta#phi [rad]");
+       // Delta Theta
+       sprintf(name, "fhDTheta%2s", ext[i].Data());
+       fhDTheta[i]   = new TH1F(name,   "DeltaTheta distribution",    320, -0.4, 0.4);    
+       fhDTheta[i]->SetXTitle("#Delta#theta [rad]");
+       // Delta Z
+       sprintf(name, "fhDZ%2s", ext[i].Data());
+       fhDZ[i]   = new TH1F(name,   "DeltaZ distribution",        200, -10., 10.);
+       fhDZ[i]->SetXTitle("#DeltaZ [cm]");
+       // Delta X
+       sprintf(name, "fhDX%2s", ext[i].Data());
+       fhDX[i]   = new TH1F(name,   "DeltaX distribution",        200, -10., 10.);
+       fhDX[i]->SetXTitle("#DeltaX [cm]");
+       // Delta Y
+       sprintf(name, "fhDY%2s", ext[i].Data());
+       fhDY[i]   = new TH1F(name,   "DeltaY distribution",        200, -10, 10.);
+       fhDY[i]->SetXTitle("#DeltaY [cm]");
+       // Delta Pt
+       sprintf(name, "fhDPt%2s", ext[i].Data());
+       fhDPt[i]   = new TH1F(name,   "DeltaPt distribution",        200, -20., 20.);
+       fhDPt[i]->SetXTitle("#Delta p_{T}  [GeV]");
+
+       // Delta 1/Pt
+       sprintf(name, "fhD1ovPt%2s", ext[i].Data());
+       fhD1ovPt[i]   = new TH1F(name,   "Delta 1/Pt distribution",        200, -1., 1.);
+       fhD1ovPt[i]->SetXTitle("#Delta 1/Pt");
+
+       // Delta Pt over Pt
+       sprintf(name, "fhDPtovPt%2s", ext[i].Data());
+       fhDPtovPt[i]   = new TH1F(name,   "DeltaPt/Pt distribution",        200, -2., 2.);
+       fhDPtovPt[i]->SetXTitle("#DeltaPt/Pt");
+
+
+
+       // Delta Pt/ Pt vs Pt
+       sprintf(name, "fpDPt%2s", ext[i].Data());
+       fpDPt[i] = new TProfile(name, "#Delta Pt / Pt", 20, 0., 20., -1, 1., "S");
+       fpDPt[i]->SetXTitle("p_{T} [GeV]");
+       fpDPt[i]->SetYTitle("#Delta 1/p_{T} [GeV^{-1}]");
+       // Delta Pt error
+       sprintf(name, "fpDPtS%2s", ext[i].Data());
+       fpDPtS[i] = new TProfile(name, "#Delta Pt / <sigma>", 20, 0., 20., 0., 10.);
+       fpDPtS[i]->SetXTitle("p_{T}");
+       fpDPtS[i]->SetYTitle("#Delta p_{T} / <#sigma_{p_{T}}>");
+
+
+       fHists->Add(fhPt[i]);
+       fHists->Add(fhPhi[i]);
+       fHists->Add(fhTheta[i]);
+       fHists->Add(fhDPhi[i]);
+       fHists->Add(fhDPt[i]);
+       fHists->Add(fhD1ovPt[i]);
+       fHists->Add(fhDPtovPt[i]);
+       fHists->Add(fhDTheta[i]);
+       fHists->Add(fhDZ[i]);
+       fHists->Add(fhDX[i]);
+       fHists->Add(fhDY[i]);
+       fHists->Add(fpDPt[i]);
+       fHists->Add(fpDPtS[i]);
+    }
+
+    fhDZvsZ      = new TH2F("fhDZvsZ",    "dz vs z", 500, -250., 250., 100, -10., 10.);
+    fhDZvsZ->SetXTitle("z_{in} * sign(z_{in}) * sign(z_{out}) [cm]");
+    fhDZvsZ->SetYTitle("#Delta z [cm]");
+    
+    
+    fhDZvsPhi    = new TH2F("fhDZvsPhi", "dz vs phi", 36, 0., TMath::Pi(),  50, -2., 2.);
+
+    fhCh1Ch2   = new TH2F("fCh1Ch2",   "ch1 vs ch2", 8, -2., 2., 8, -2., 2.);
+    fhPh1Ph2   = new TH2F("fPh1Ph2",   "ph1 vs ph2", 128, 0., 2. * TMath::Pi(), 128, 0., 2. * TMath::Pi());
+    fhCl1Cl2G  = new TH2F("fCl1Cl2G",   "#cl vs #cl", 200, 0., 200., 200, 0., 200);
+    fhCl1Cl2B  = new TH2F("fCl1Cl2B",   "#cl vs #cl", 200, 0., 200., 200, 0., 200);    
+
+    fHists->Add(fhDZvsZ);
+    fHists->Add(fhDZvsPhi);
+    fHists->Add(fhCh1Ch2);
+    fHists->Add(fhPh1Ph2);
+    fHists->Add(fhCl1Cl2G);
+    fHists->Add(fhCl1Cl2B);
+    fHists->SetOwner();
+
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskCosmic::UserExec(Option_t *) 
+{
+  // Main loop
+  // Called for each event
+
+  if (!fInputEvent) {
+    Printf("ERROR: fESD not available");
+    return;
+  }
+  
+  AliESDEvent* esdE = (AliESDEvent*)fInputEvent;
+  if (esdE->GetNumberOfTracks() != 2) return;
+  
+  for (Int_t iTracks = 0; iTracks < esdE->GetNumberOfTracks(); iTracks++) {
+      AliESDtrack* track = esdE->GetTrack(iTracks);
+
+
+      
+//      const AliExternalTrackParam * track = trackG->GetTPCInnerParam();
+//      if (!track) continue;
+      // Pt cut
+      Float_t pt     = track->Pt();
+      Float_t charge = track->Charge();
+      Float_t phi    = track->Phi();
+      if (phi > 0. && phi  < TMath::Pi()) charge*=(-1.);
+
+
+
+      // TPC track
+      UInt_t status = track->GetStatus();
+      if (status&AliESDtrack::kTPCrefit ==0) continue;
+
+      Int_t nClustersTPC = track->GetTPCclusters(0);
+      if (nClustersTPC < 50) continue;
+      
+      // 
+
+      Float_t z      = track->GetZ();
+      Float_t x      = track->Xv();
+      Float_t y      = track->Yv();
+      Float_t theta  = track->Theta();
+
+
+      const AliExternalTrackParam * trackOut = track->GetOuterParam();
+      Float_t zOut = 0.;
+      if (trackOut)zOut = trackOut->Zv();
+      
+
+      if (charge > 0) {
+         fhPt[kPosC]   ->Fill(pt);
+      } else {
+         fhPt[kNegC]   ->Fill(pt);
+      }
+
+      //      if ((TMath::Abs(esdE->GetCurrentL3()) > 1.e-3) && (pt < 1. || pt > 50.)) continue;
+
+      
+      //
+      if (charge > 0) {
+         fhPhi[kPosC]  ->Fill(phi);
+         fhTheta[kPosC]->Fill(theta);
+      } else {
+         fhPhi[kNegC]  ->Fill(phi);
+         fhTheta[kNegC]->Fill(theta);
+      }
+
+      
+      if (z > 0) {
+         fhPt[kPosZ]   ->Fill(pt);
+         fhPhi[kPosZ]  ->Fill(phi);
+         fhTheta[kPosZ]->Fill(theta);
+      } else {
+         fhPt[kNegZ]   ->Fill(pt);
+         fhPhi[kNegZ]  ->Fill(phi);
+         fhTheta[kNegZ]->Fill(theta);
+      }
+
+
+
+      // Tracks coming from above
+      if (phi > 0. &&  phi < TMath::Pi()) {
+         
+//       printf("Track#1 %5d %5d %13.3f %13.3f \n", Int_t(Entry()), iTracks, phi, zOut);
+         
+         Float_t dphiMin = 999.;
+         Float_t rMin    = 999.;
+         Int_t   jMin    = -1;
+         // Search for a matching track (in dphi-dtheta)
+         for (Int_t jTracks = 0; jTracks < esdE->GetNumberOfTracks(); jTracks++) {
+             if (jTracks == iTracks) continue;
+
+             AliESDtrack* track2 = esdE->GetTrack(jTracks);
+
+             UInt_t status = track2->GetStatus();
+             if (status&AliESDtrack::kTPCrefit ==0) continue;
+
+             Int_t nClustersTPC2 = track2->GetTPCclusters(0);
+             if (nClustersTPC2 < 50) continue;
+             //              if ((TMath::Abs(esdE->GetCurrentL3()) > 1.e-3) && (track2->Pt() < 1. || track2->Pt() > 50.)) continue;
+//           const AliExternalTrackParam * track2 = trackG2->GetTPCInnerParam();
+//           if (!track2) continue;
+             
+             Float_t phi2   = track2->Phi() - TMath::Pi();
+             Float_t theta2 = TMath::Pi()   - track2->Theta();
+             Float_t dphi   = phi2   - phi;
+             Float_t dtheta = theta2 - theta;
+             
+             if (dphi >  TMath::Pi()) dphi -= 2. * TMath::Pi();
+             if (dphi < -TMath::Pi()) dphi += 2. * TMath::Pi();
+
+             Float_t dR = TMath::Sqrt(dphi * dphi + dtheta * dtheta);
+
+             if (dR < rMin) {
+                 rMin    = dR;
+                 dphiMin = dphi;
+                 jMin = jTracks;
+             }
+
+         } // tracks 2
+         if (jMin != -1) {
+             // we found a matching track candidate ...
+             AliESDtrack* track2 = esdE->GetTrack(jMin);
+             const AliExternalTrackParam * trackOut2 = track2->GetOuterParam();
+             Float_t zOut2 = 0.;
+             if (trackOut2) zOut2 = trackOut2->Zv();
+
+
+             Float_t theta2 = - track2->Theta() + TMath::Pi();
+             Float_t z2 = track2->GetZ();
+             Float_t x2 = track2->Xv();
+             Float_t y2 = track2->Yv();
+             Float_t charge2 = track2->Charge();
+             Float_t dz  = z2 - z;
+             Float_t dx  = x2 - x;
+             Float_t dy  = y2 - y;
+             Float_t pt1 = track->Pt();
+             Float_t pt2 = track2->Pt();
+             Float_t dpt = pt2 - pt1;
+             Float_t d1pt = 1./pt2 - 1./pt1;
+             
+             Float_t ptm = 0.5 * (pt1 + pt2);
+
+             Int_t nClustersTPC2 = track2->GetTPCclusters(0);
+
+             if (charge > 0.) {
+                 fhDPhi[kPosC]  ->Fill(dphiMin);
+                 fhDTheta[kPosC]->Fill(theta2 - theta);
+             } else {
+                 fhDPhi[kNegC]  ->Fill(dphiMin);
+                 fhDTheta[kNegC]->Fill(theta2 - theta);
+             }
+
+             if (z > 0.) {
+                 fhDPhi[kPosZ]  ->Fill(dphiMin);
+                 fhDTheta[kPosZ]->Fill(theta2 - theta);
+             } else {
+                 fhDPhi[kNegZ]  ->Fill(dphiMin);
+                 fhDTheta[kNegZ]->Fill(theta2 - theta);
+             }
+
+             if (TMath::Abs(dpt)/ptm > 0.5) {
+                 fhDPhi[kBad]  ->Fill(dphiMin);
+                 fhDTheta[kBad]->Fill(theta2 - theta);
+             } else {
+                 fhDPhi[kGood]  ->Fill(dphiMin);
+                 fhDTheta[kGood]->Fill(theta2 - theta);
+             }
+             // Good matches ...             
+//           if (TMath::Abs(rMin < 0.04) && (charge == charge2) && TMath::Abs(dz) < 0.5 &&  TMath::Abs(dy) && TMath::Abs(dx) < 0.5 ) 
+//           if (TMath::Abs(rMin < 0.04) && (charge == charge2) && (zOut * zOut2) < 0.) 
+             if (TMath::Abs(rMin < 0.04) && (charge == charge2)) 
+             {
+
+                 if (TMath::Abs(dpt)/ptm  < .1) {
+                     fhCl1Cl2G->Fill(nClustersTPC, nClustersTPC2);
+                 }
+                 
+                 if (TMath::Abs(dpt)/ptm  > .5) fhCl1Cl2B->Fill(nClustersTPC, nClustersTPC2);
+                 fhPh1Ph2->Fill(track->Phi(), track2->Phi());
+
+
+                 Double_t sigmaPt1 = TMath::Sqrt(track->GetSigma1Pt2());
+                 Double_t sigmaPt2 = TMath::Sqrt(track->GetSigma1Pt2());
+                 Double_t sigmaPt = 0.5 * TMath::Sqrt(sigmaPt1 * sigmaPt1 + sigmaPt2 * sigmaPt2);
+                 if (TMath::Abs(dpt)/ptm > 0.2 && pt > 10. &&  charge > 0.)
+//                   printf("Track#2 %5d %5d %13.3f %13.3f %13.3f %13.3f\n", Entry(), jMin, track2->Phi(), dz, dpt, zOut2);                      
+                 if (zOut != 0. && zOut2 != 0.) fhDZvsZ->Fill(TMath::Abs(zOut) * zOut/zOut2, dz);
+                 if (zOut * zOut2 > 0. && zOut < 0) fhDZvsPhi->Fill(phi, dz);
+                 
+                 fhCh1Ch2->Fill(charge, track2->Charge());
+                 
+                 
+                 if (charge > 0.) {
+                     fhDPt[kPosC]->Fill(dpt);
+                     fhD1ovPt[kPosC]->Fill(d1pt);
+                     fpDPt[kPosC]->Fill(ptm, d1pt);
+                     if (ptm > 5. && ptm < 15.) fhDPtovPt[kPosC]->Fill(dpt/ptm);
+                     fhDZ[kPosC]->Fill(dz);
+                     fhDX[kPosC]->Fill(dx);
+                     fhDY[kPosC]->Fill(dy);
+                     fpDPtS[kPosC]->Fill(ptm, 2. * TMath::Abs(1./pt1 - 1./pt2)/sigmaPt);
+                 } else {
+                     fhDPt[kNegC]->Fill(dpt);
+                     fhD1ovPt[kNegC]->Fill(d1pt);
+                     fpDPt[kNegC]->Fill(ptm, d1pt);
+                     if (ptm > 5. && ptm < 15.) fhDPtovPt[kNegC]->Fill(dpt/ptm);
+                     fhDZ[kNegC]->Fill(dz);
+                     fhDX[kNegC]->Fill(dx);
+                     fhDY[kNegC]->Fill(dy);
+                     fpDPtS[kNegC]->Fill(ptm, 2. * TMath::Abs(1./pt1 - 1./pt2)/sigmaPt);
+                 }
+
+                 if (z > 0.) {
+                     fhDPt[kPosZ]->Fill(dpt);
+                     fhD1ovPt[kPosZ]->Fill(d1pt);
+                     fpDPt[kPosZ]->Fill(ptm, d1pt);
+                     fhDZ[kPosZ]->Fill(dz);
+                     fhDX[kPosZ]->Fill(dx);
+                     fhDY[kPosZ]->Fill(dy);
+                     fpDPtS[kPosZ]->Fill(ptm, 2. * TMath::Abs(1./pt1 - 1./pt2)/sigmaPt);
+                 } else {
+                     fhDPt[kNegZ]->Fill(dpt);
+                     fhD1ovPt[kNegZ]->Fill(d1pt);
+                     fpDPt[kNegZ]->Fill(ptm, d1pt);
+                     fhDZ[kNegZ]->Fill(dz);
+                     fhDX[kNegZ]->Fill(dx);
+                     fhDY[kNegZ]->Fill(dy);
+                     fpDPtS[kNegZ]->Fill(ptm, 2. * TMath::Abs(1./pt1 - 1./pt2)/sigmaPt);
+                 } 
+
+
+                 if (TMath::Abs(dpt)/ptm > 0.5) {
+                     fhDPt[kBad]->Fill(dpt);
+                     fpDPt[kBad]->Fill(ptm, TMath::Abs(dpt)/ptm);
+                     fhDZ[kBad]->Fill(dz);
+                     fhDX[kBad]->Fill(dx);
+                     fhDY[kBad]->Fill(dy);
+                     fpDPtS[kBad]->Fill(ptm, 2. * TMath::Abs(1./pt1 - 1./pt2)/sigmaPt);
+                 } else {
+                     fhDPt[kGood]->Fill(dpt);
+                     fpDPt[kGood]->Fill(ptm, TMath::Abs(dpt)/ptm);
+                     fhDZ[kGood]->Fill(dz);
+                     fhDX[kGood]->Fill(dx);
+                     fhDY[kGood]->Fill(dy);
+                     fpDPtS[kGood]->Fill(ptm, 2. * TMath::Abs(1./pt1 - 1./pt2)/sigmaPt);
+                 } 
+                 
+             } // good matches
+         } // found possible match
+      } // upper
+  } // tracks 1
+  PostData(1, fHists);
+}      
+
+//________________________________________________________________________
+void AliAnalysisTaskCosmic::Terminate(Option_t *) 
+{
+}  

diff --git a/PWG1/cosmic/AliAnalysisTaskCosmic.h b/PWG1/cosmic/AliAnalysisTaskCosmic.h
new file mode 100644 (file)
index 0000000..5fb9d36
--- /dev/null
+++ b/PWG1/cosmic/AliAnalysisTaskCosmic.h
@@ -0,0 +1,65 @@
+// gSystem->SetIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/include");\r
+#ifndef AliAnalysisTaskCosmic_cxx\r
+#define AliAnalysisTaskCosmic_cxx\r
+\r
+\r
+class TH1F;\r
+class TH2F;\r
+\r
+class TProfile;\r
+\r
+class TList;\r
+class TClonesArray;\r
+\r
+\r
+#include "AliAnalysisTaskSE.h"\r
+\r
+enum SelType {\r
+   kPosC   = 0,\r
+   kNegC   = 1,\r
+   kPosZ   = 2,\r
+   kNegZ   = 3,\r
+   kGood   = 4,\r
+   kBad    = 5\r
+};   \r
+\r
+class AliAnalysisTaskCosmic : public AliAnalysisTaskSE {\r
+ public:\r
+  AliAnalysisTaskCosmic(const char *name = "AliAnalysisTaskCosmic");\r
+  virtual ~AliAnalysisTaskCosmic() {}\r
+  \r
+  virtual void   UserCreateOutputObjects();\r
+  virtual void   UserExec(Option_t *option);\r
+  virtual void   Terminate(Option_t *);\r
+ private:\r
+  TList*          fHists;        // List of histograms\r
+  TH1F*           fhPt[6];       // Pt distribution\r
+  TH1F*           fhTheta[6];    // Eta distribution\r
+  TH1F*           fhPhi[6];      // Phi distribution\r
+  TH1F*           fhDPhi[6];     // DeltaPhi\r
+  TH1F*           fhDTheta[6];   // DeltaTheta\r
+  TH1F*           fhDZ[6];       // DeltaZ\r
+  TH1F*           fhDX[6];       // DeltaX\r
+  TH1F*           fhDY[6];       // DeltaY\r
+  TH1F*           fhDPt[6];      // DeltaPt\r
+  TH1F*           fhD1ovPt[6];   // Delta 1/Pt\r
+  \r
+\r
+  TH1F*           fhDPtovPt[6];  // DeltaPt/pt\r
+  \r
+      \r
+  TH2F*           fhDZvsZ;       // dz vs z\r
+  TH2F*           fhDZvsPhi;     // dz vs phi\r
+    \r
+  TH2F*           fhCh1Ch2;      // ch1 vs ch2\r
+  TH2F*           fhPh1Ph2;      // phi1 vs phi2\r
+  TH2F*           fhCl1Cl2G;     // #Clusters\r
+  TH2F*           fhCl1Cl2B;     // #Clusters\r
+    \r
+  TProfile*       fpDPt[6];      // delta pt / <pt>\r
+  TProfile*       fpDPtS[6];     // delta_pt / <error_pt>\r
+  \r
+  ClassDef(AliAnalysisTaskCosmic, 1); // example of analysis\r
+};\r
+\r
+#endif\r

diff --git a/prod/acrcaf/qa.sh b/prod/acrcaf/qa.sh
new file mode 100644 (file)
index 0000000..145ba20
--- /dev/null
+++ b/prod/acrcaf/qa.sh
@@ -0,0 +1,8 @@
+#!/bin/bash
+
+  [ -d qa ] || mkdir qa
+
+  [ -z $1 ] && { echo "Usage: qa.sh <run_number>"; exit 1; }
+
+  cd qa
+  aliroot qa.C\($1\)

diff --git a/prod/acrcaf/qa/qa.C b/prod/acrcaf/qa/qa.C
new file mode 100644 (file)
index 0000000..9aa8fe3
--- /dev/null
+++ b/prod/acrcaf/qa/qa.C
@@ -0,0 +1,308 @@
+void qa(Int_t runNumber) {
+  TStopwatch timer;
+  timer.Start();
+
+  gEnv->SetValue("XSec.GSI.DelegProxy","2");
+  // Select ROOT version
+  TProof::Mgr("aliprod@alicecaf")->SetROOTVersion("v5-24-00b-caf");
+  // Login to CAF
+  TProof::Open("aliprod@alicecaf");
+
+  // Enable AliRoot
+  gProof->UploadPackage("/afs/cern.ch/alice/caf/sw/ALICE/PARs/v4-17-Release.rec/AF-v4-17-rec.par");
+  gProof->EnablePackage("AF-v4-17-rec.par");
+
+  gProof->Load(Form("%s/AliAnalysisTaskCosmic.cxx++g",
+                   gSystem->ExpandPathName("$ALICE_ROOT/PWG1/cosmic"));
+
+  //____________________________________________//
+  // Make the analysis manager
+  AliAnalysisManager *mgr = new AliAnalysisManager("AnalysisQAManager");
+  AliESDInputHandler* esdH = new AliESDInputHandler();
+  mgr->SetInputEventHandler(esdH);  
+  mgr->SetDebugLevel(10);
+
+  //____________________________________________//
+  // 1st Cosmic task
+  AliAnalysisTaskCosmic *task1 = new AliAnalysisTaskCosmic("TaskCosmic");
+  mgr->AddTask(task1);
+
+  // Create containers for input/output
+  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("chist1",TList::Class(),AliAnalysisManager::kOutputContainer,
+                                                           Form("run%d.root",runNumber));
+
+  //____________________________________________//
+  mgr->ConnectInput  (task1,  0, mgr->GetCommonInputContainer());
+  mgr->ConnectOutput (task1,  1, coutput1);
+  
+  if (!mgr->InitAnalysis()) return;
+  mgr->PrintStatus();
+  mgr->StartAnalysis("proof",
+                    Form("ALIREC/aliprod/run%d",runNumber));
+
+  timer.Stop();
+  timer.Print();
+
+  plot(runNumber);
+}
+
+void plot(Int_t runNumber)
+{
+  TFile* f = new TFile(Form("run%d.root",runNumber), "read");
+
+  // pt, phi ....
+  TCanvas* c1 = new TCanvas("c1", "pt,eta,phi", 10, 10, 1100, 800);
+  c1->Divide(2,2);
+  c1->cd(1);
+  c1->GetPad(1)->SetLogy();
+    
+  fhPtP = (TH1F*) chist1->FindObject("fhPtPC");
+  fhPtP->SetLineColor(2);
+  fhPtP->Draw();
+  fhPtN = (TH1F*) chist1->FindObject("fhPtNC");
+  fhPtN->SetLineColor(4);
+  fhPtN->Draw("same");
+
+  c1->cd(2);
+  fhPhiP = (TH1F*) chist1->FindObject("fhPhiPC");
+  fhPhiP->SetLineColor(2);
+  fhPhiP->Draw();
+  fhPhiN = (TH1F*) chist1->FindObject("fhPhiNC");
+  fhPhiN->SetLineColor(4);
+  fhPhiN->Draw("same");
+
+  c1->cd(3);
+  fhThetaP = (TH1F*) chist1->FindObject("fhThetaPC");
+  fhThetaP->SetLineColor(2);
+  fhThetaP->Draw();
+  fhThetaN = (TH1F*) chist1->FindObject("fhThetaNC");
+  fhThetaN->SetLineColor(4);
+  fhThetaN->Draw("same");
+
+    
+  // delta phi
+  TCanvas* c2 = new TCanvas("c2", "#Delta#phi", 10, 10, 1100, 800);
+  c2->Divide(2,2);
+  // pos/neg charge
+  c2->cd(1);
+  c2->GetPad(1)->SetLogy();
+  fhDPhiP = (TH1F*) chist1->FindObject("fhDPhiPC");
+  fhDPhiN = (TH1F*) chist1->FindObject("fhDPhiNC");
+  fhDPhiP->SetLineColor(2);
+  fhDPhiN->SetLineColor(4);
+  fhDPhiP->SetXTitle("#Delta#phi [rad]");
+  fhDPhiP->Draw();
+  fhDPhiN->Draw("same");
+
+  // pos/neg z
+  c2->cd(2);
+  c2->GetPad(2)->SetLogy();
+
+  fhDPhiZP = (TH1F*) chist1->FindObject("fhDPhiPZ");
+  fhDPhiZN = (TH1F*) chist1->FindObject("fhDPhiNZ");
+  fhDPhiBA = (TH1F*) chist1->FindObject("fhDPhi_Bad");
+  fhDPhiZP->SetLineColor(2);
+  fhDPhiZN->SetLineColor(4);
+  fhDPhiBA->SetLineColor(6);
+
+  fhDPhiZP->SetXTitle("#Delta#phi [rad]");
+  fhDPhiZP->Draw();
+  fhDPhiZN->Draw("same");
+  //  fhDPhiBA->Draw("same");
+
+    
+  // delta theta
+  // pos/neg charge
+  c2->cd(3);
+  c2->GetPad(3)->SetLogy();
+  fhDThetaP = (TH1F*) chist1->FindObject("fhDThetaPC");
+  fhDThetaN = (TH1F*) chist1->FindObject("fhDThetaNC");
+  fhDThetaP->SetLineColor(2);
+  fhDThetaN->SetLineColor(4);
+ 
+
+  fhDThetaP->SetXTitle("#Delta#theta [rad]");
+  fhDThetaP->Draw();
+  fhDThetaN->Draw("same");
+
+  // pos/neg z
+  c2->cd(4);
+  c2->GetPad(4)->SetLogy();
+
+  fhDThetaZP = (TH1F*) chist1->FindObject("fhDThetaPZ");
+  fhDThetaZN = (TH1F*) chist1->FindObject("fhDThetaNZ");
+  fhDThetaBA = (TH1F*) chist1->FindObject("fhDTheta_Bad");
+  fhDThetaZP->SetLineColor(2);
+  fhDThetaZN->SetLineColor(4);
+  fhDThetaBA->SetLineColor(6);
+  fhDThetaZP->SetXTitle("#Delta#theta [rad]");
+  fhDThetaZP->Draw();
+
+  fhDThetaZN->Draw("same");
+  //    fhDThetaBA->Draw("same");
+
+    
+  // delta Pt
+  TCanvas* c3 = new TCanvas("c3", "#Delta p_{T}", 10, 10, 1100, 800);
+  c3->Divide(2,2);
+  // pos/neg charge
+  c3->cd(1);
+  c3->GetPad(1)->SetLogy();
+  fhDPtP = (TH1F*) chist1->FindObject("fhDPtPC");
+  fhDPtN = (TH1F*) chist1->FindObject("fhDPtNC");
+  fhDPtP->SetLineColor(2);
+  fhDPtN->SetLineColor(4);
+    
+  fhDPtP->Draw();
+  fhDPtN->Draw("same");
+
+  // pos/neg z
+  c3->cd(2);
+  c3->GetPad(2)->SetLogy();
+
+  fhDPtZP = (TH1F*) chist1->FindObject("fhDPtPZ");
+  fhDPtZN = (TH1F*) chist1->FindObject("fhDPtNZ");
+  fhDPtZP->SetLineColor(2);
+  fhDPtZN->SetLineColor(4);
+  fhDPtZP->Draw();
+  fhDPtZN->Draw("same");
+
+  c3->cd(3);
+
+  fpDPtP = (TH1F*) chist1->FindObject("fpDPtPC");
+  fpDPtN = (TH1F*) chist1->FindObject("fpDPtNC");
+  fpDPtP->SetLineColor(2);
+  fpDPtN->SetLineColor(4);
+  fpDPtP->Draw();
+  fpDPtN->Draw("same");
+
+  c3->cd(4);
+
+  fpDPtZP = (TH1F*) chist1->FindObject("fpDPtPZ");
+  fpDPtZN = (TH1F*) chist1->FindObject("fpDPtNZ");
+  fpDPtZP->SetLineColor(2);
+  fpDPtZN->SetLineColor(4);
+  fpDPtZP->Draw();
+  fpDPtZN->Draw("same");
+    
+
+  // dZ
+  TCanvas* c4 = new TCanvas("c4", "#Delta Z", 10, 10, 1100, 800);
+  c4->Divide(2,2);
+  // pos/neg charge
+  c4->cd(1);
+  c4->GetPad(1)->SetLogy();
+  fhDZP = (TH1F*) chist1->FindObject("fhDZPC");
+  fhDZN = (TH1F*) chist1->FindObject("fhDZNC");
+  fhDZP->SetLineColor(2);
+  fhDZN->SetLineColor(4);
+    
+  fhDZP->Draw();
+  fhDZN->Draw("same");
+  
+  // pos/neg z
+  c4->cd(2);
+  c4->GetPad(2)->SetLogy();
+
+  fhDZZP = (TH1F*) chist1->FindObject("fhDZPZ");
+  fhDZZN = (TH1F*) chist1->FindObject("fhDZNZ");
+  fhDZBA = (TH1F*) chist1->FindObject("fhDZ_Bad");
+
+  fhDZZP->SetLineColor(2);
+  fhDZZN->SetLineColor(4);
+  fhDZBA->SetLineColor(6);
+  
+  fhDZZP->Draw();
+  fhDZZN->Draw("same");
+  fhDZBA->Draw("same");
+
+  // dX
+  // pos/neg charge
+  c4->cd(3);
+  c4->GetPad(3)->SetLogy();
+  fhDXP = (TH1F*) chist1->FindObject("fhDXPC");
+  fhDXN = (TH1F*) chist1->FindObject("fhDXNC");
+  fhDXP->SetLineColor(2);
+  fhDXN->SetLineColor(4);
+    
+  fhDXP->Draw();
+  fhDXN->Draw("same");
+
+  // pos/neg z
+  c4->cd(4);
+  c4->GetPad(4)->SetLogy();
+
+  fhDXZP = (TH1F*) chist1->FindObject("fhDXPZ");
+  fhDXZN = (TH1F*) chist1->FindObject("fhDXNZ");
+  fhDXBA = (TH1F*) chist1->FindObject("fhDX_Bad");
+
+  fhDXZP->SetLineColor(2);
+  fhDXZN->SetLineColor(4);
+  fhDXBA->SetLineColor(6);
+
+  fhDXZP->Draw();
+  fhDXZN->Draw("same");
+  fhDXBA->Draw("same");
+
+  // dY
+  TCanvas* c4a = new TCanvas("c4a", "#Delta Y", 10, 10, 1100, 800);
+  c4a->Divide(2,2);
+  // pos/neg charge
+  c4a->cd(1);
+  c4a->GetPad(1)->SetLogy();
+  fhDYP = (TH1F*) chist1->FindObject("fhDYPC");
+  fhDYN = (TH1F*) chist1->FindObject("fhDYNC");
+  fhDYP->SetLineColor(2);
+  fhDYN->SetLineColor(4);
+  
+  fhDYP->Draw();
+  fhDYN->Draw("same");
+
+  // pos/neg z
+  c4a->cd(2);
+  c4a->GetPad(2)->SetLogy();
+
+  fhDYZP = (TH1F*) chist1->FindObject("fhDYPZ");
+  fhDYZN = (TH1F*) chist1->FindObject("fhDYNZ");
+  fhDYBA = (TH1F*) chist1->FindObject("fhDY_Bad");
+  
+  fhDYZP->SetLineColor(2);
+  fhDYZN->SetLineColor(4);
+  fhDYBA->SetLineColor(6);
+
+  fhDYZP->Draw();
+  fhDYZN->Draw("same");
+  fhDYBA->Draw("same");
+
+  // delta Pt
+  TCanvas* c5 = new TCanvas("c5", "#Delta p_{T} (n-sigma)", 10, 10, 1100, 800);
+  c5->Divide(2,2);
+  c5->cd(1);
+
+  fpDPtSP = (TH1F*) chist1->FindObject("fpDPtSPC");
+  fpDPtSN = (TH1F*) chist1->FindObject("fpDPtSNC");
+  fpDPtSP->SetLineColor(2);
+  fpDPtSN->SetLineColor(4);
+  fpDPtSP->Draw();
+  fpDPtSN->Draw("same");
+
+
+  c5->cd(2);
+
+  fpDPtSPZ = (TH1F*) chist1->FindObject("fpDPtSPZ");
+  fpDPtSNZ = (TH1F*) chist1->FindObject("fpDPtSNZ");
+  fpDPtSPZ->SetLineColor(2);
+  fpDPtSNZ->SetLineColor(4);
+  fpDPtSPZ->Draw();
+  fpDPtSNZ->Draw("same");
+
+  TCanvas* c6 = new TCanvas("c6", "Dz vs z", 10, 10, 1100, 800);
+  fhDZvsZ = (TH2F*) chist1->FindObject("fhDZvsZ");
+  fhDZvsZ->SetXTitle("z_{in} * sign(z_{in}) * sign(z_{out}) [cm]");
+  fhDZvsZ->SetYTitle("#DeltaZ [cm]");
+
+  gStyle->SetPalette(1);
+    
+  fhDZvsZ->Draw("colz");
+}
+