Adding a task for running the GlobalQA over the ESD files.

diff --git a/PWG1/PWG1LinkDef.h b/PWG1/PWG1LinkDef.h
index cb756b99aaab22412a53c84ce62e4e43095522fe..7818a2e9cb8cb73af771d9d2de8c0fe064459760 100644 (file)
--- a/PWG1/PWG1LinkDef.h
+++ b/PWG1/PWG1LinkDef.h
@@ -9,6 +9,8 @@
 #pragma link C++ class AliESDresolParams+;
 #pragma link C++ class AliESDresolMakerFast+;
 
+#pragma link C++ class AliAnalysisTaskGlobalQA+;
+
 #pragma link C++ class AliTreeDraw+;
 //
 #pragma link C++ class AliTPCdigitRow+;

diff --git a/PWG1/global/AliAnalysisTaskGlobalQA.cxx b/PWG1/global/AliAnalysisTaskGlobalQA.cxx
new file mode 100644 (file)
index 0000000..790f559
--- /dev/null
+++ b/PWG1/global/AliAnalysisTaskGlobalQA.cxx
@@ -0,0 +1,344 @@
+
+/**************************************************************************
+ *  Authors : Iouri Belikov, Antonin Maire
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+//-----------------------------------------------------------------
+//                 AliAnalysisTaskGlobalQA class
+// This task is for running the GlobalQA over already existing ESDs
+//          Origin:  I.Belikov, Iouri.Belikov@cern.ch, June 2009
+//-----------------------------------------------------------------
+
+#include <TPDGCode.h>
+
+#include "TChain.h"
+#include "TTree.h"
+#include "TH1F.h"
+#include "TH2F.h"
+#include "TCanvas.h"
+
+#include "AliAnalysisManager.h"
+
+#include "AliESDEvent.h"
+#include "AliESDv0.h"
+#include "AliESDInputHandler.h"
+
+#include "AliAnalysisTaskGlobalQA.h"
+
+//
+// Run the GlobalQA analysis over already existing ESDs
+// Origin: Iouri.Belikov@cern.ch
+//
+
+ClassImp(AliAnalysisTaskGlobalQA)
+
+//________________________________________________________________________
+AliAnalysisTaskGlobalQA::AliAnalysisTaskGlobalQA() : 
+ AliAnalysisTaskSE("GlobalQA"), 
+ fArrayQA(0)
+{
+  // Default Constructor
+
+  DefineOutput(1, TObjArray::Class());
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskGlobalQA::UserCreateOutputObjects()
+{
+  // Create the histograms
+  // Called once
+
+  fArrayQA = new TObjArray(kLast);
+
+
+  {// Cluster related QA
+    const Char_t *name[]={
+      "hGlobalFractionAssignedClustersITS",
+      "hGlobalFractionAssignedClustersTPC",
+      "hGlobalFractionAssignedClustersTRD"
+    };
+  const Char_t *title[]={
+    "Fraction of the assigned clusters in ITS",
+    "Fraction of the assigned clusters in TPC",
+    "Fraction of the assigned clusters in TRD"
+  };
+  Add2ESDsList(new TH1F(name[0],title[0],100,0.,2.),kClr0);
+  Add2ESDsList(new TH1F(name[1],title[1],100,0.,2.),kClr1);
+  Add2ESDsList(new TH1F(name[2],title[2],100,0.,2.),kClr2);
+  }
+
+  {// Track related QA
+    const Char_t *name[]={
+      "hGlobalTrackAzimuthe",                               // kTrk0
+      "hGlobalTrackEta",                                    // kTrk1
+      "hGlobalTPCTrackpT",                                  // kTrk2
+      "hGlobalTPCITSMatchedpT",                             // kTrk3
+      "hGlobalTPCTOFMatchedpT",                             // kTrk4
+      "hGlobalTPCITSMatchingProbability",                   // kTrk5
+      "hGlobalTPCTOFMatchingProbability",                   // kTrk6
+      "hGlobalTPCsideAposDCA",                              // kTrk7
+      "hGlobalTPCsideAnegDCA",                              // kTrk8
+      "hGlobalTPCsideCposDCA",                              // kTrk9
+      "hGlobalTPCsideCnegDCA"                               // kTrk10
+  };
+  const Char_t *title[]={
+    "Track azimuthal distribution (rad)",                   // kTrk0
+    "Track pseudo-rapidity distribution",                   // kTrk1
+    "TPC: track momentum distribution (GeV)",               // kTrk2
+    "TPC-ITS matched: track momentum distribution (GeV)",   // kTrk3
+    "TPC-TOF matched: track momentum distribution (GeV)",   // kTrk4
+    "TPC-ITS track-matching probability",                   // kTrk5
+    "TPC-TOF track-matching probability"                    // kTrk6
+    "TPC side A: DCA for the positive tracks (mm)",         // kTrk7
+    "TPC side A: DCA for the negative tracks (mm)",         // kTrk8
+    "TPC side C: DCA for the positive tracks (mm)",         // kTrk9
+    "TPC side C: DCA for the negative tracks (mm)"          // kTrk10
+  };
+  Add2ESDsList(new TH1F(name[0],title[0],100, 0.,TMath::TwoPi()),kTrk0);
+  Add2ESDsList(new TH1F(name[1],title[1],100,-2.00,2.00),kTrk1);
+  Add2ESDsList(new TH1F(name[2],title[2],50,  0.20,5.00),kTrk2);
+  Add2ESDsList(new TH1F(name[3],title[3],50,  0.20,5.00),kTrk3);
+  Add2ESDsList(new TH1F(name[4],title[4],50,  0.20,5.00),kTrk4);
+  Add2ESDsList(new TH1F(name[5],title[5],50,  0.20,5.00),kTrk5);
+  Add2ESDsList(new TH1F(name[6],title[6],50,  0.20,5.00),kTrk6);
+  Add2ESDsList(new TH1F(name[7],title[7],50, -25.0,25.0),kTrk7);
+  Add2ESDsList(new TH1F(name[8],title[8],50, -25.0,25.0),kTrk8);
+  Add2ESDsList(new TH1F(name[9],title[9],50, -25.0,25.0),kTrk9);
+  Add2ESDsList(new TH1F(name[10],title[10],50, -25.0,25.0),kTrk10);
+  }
+
+  {// V0 related QA
+    const Char_t *name[]={
+      "hGlobalPromptK0sMass",
+      "hGlobalOfflineK0sMass",
+      "hGlobalPromptLambda0Lambda0BarMass",
+      "hGlobalOfflineLambda0Lambda0BarMass"
+    };
+  const Char_t *title[]={
+    "On-the-fly K0s mass (GeV)",
+    "Offline K0s mass (GeV)",
+    "On-the-fly Lambda0 + Lambda0Bar mass (GeV)",
+    "Offline Lambda0 + Lambda0Bar mass (GeV)"
+  };
+  Add2ESDsList(new TH1F(name[0],title[0],50,  0.4477,0.5477),kK0on);
+  Add2ESDsList(new TH1F(name[1],title[1],50,  0.4477,0.5477),kK0off);
+  Add2ESDsList(new TH1F(name[2],title[2],50,  1.0657,1.1657),kL0on);
+  Add2ESDsList(new TH1F(name[3],title[3],50,  1.0657,1.1657),kL0off);
+  }
+
+  {// PID related QA
+  const Char_t *name[]={
+    "hGlobalITSdEdx",
+    "hGlobalTPCdEdx",
+    "hGlobalTOFTrackingvsMeasured",
+    "hGlobalTPCdEdxvsMomentum"
+  };
+  const Char_t *title[]={
+    "ITS: dEdx (A.U.) for particles with momentum 0.4 - 0.5 (GeV)",
+    "TPC: dEdx (A.U.) for particles with momentum 0.4 - 0.5 (GeV)",
+    "TOF: tracking - measured (ps)",
+    "TPC: dEdx (A.U.) vs momentum (GeV)"
+  };
+  Add2ESDsList(new TH1F(name[0],title[0],50,0.00,200.),kPid0);
+  Add2ESDsList(new TH1F(name[1],title[1],50,0.00,100.),kPid1);
+  Add2ESDsList(new TH1F(name[2],title[2],50,-3500.,3500.),kPid2);
+  Add2ESDsList(new TH2F(name[3],title[3],1500,0.05,15.,700,0.,700.),kPid3);
+  }
+
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskGlobalQA::UserExec(Option_t *) 
+{
+  // Main loop
+  // Called for each event
+  
+  const AliESDEvent *esd=(const AliESDEvent *)InputEvent();
+
+  if (!esd) {
+    Printf("ERROR: ESD is not available");
+    return;
+  }
+
+  for (Int_t iTracks = 0; iTracks < esd->GetNumberOfTracks(); iTracks++) {
+      AliESDtrack* track = esd->GetTrack(iTracks);
+      if (!track) {
+         Printf("ERROR: Could not receive track %d", iTracks);
+         continue;
+      }
+
+
+    // Cluster related QA
+    if (track->IsOn(AliESDtrack::kITSrefit)) {
+      Int_t n=track->GetITSclusters(0);
+      GetESDsData(kClr0)->Fill(Float_t(n)/6.); //6 is the number of ITS layers
+    }
+
+    if (track->IsOn(AliESDtrack::kTPCrefit)) {
+      Int_t n =track->GetTPCNcls();
+      Int_t nf=track->GetTPCNclsF();      // number of crossed TPC pad rows
+      if (nf>0) {
+        Double_t val = n*1.0/nf; 
+        GetESDsData(kClr1)->Fill(val); 
+      }
+    }
+
+    if (track->IsOn(AliESDtrack::kTRDrefit)) {
+      Int_t n=track->GetTRDclusters(0);
+      GetESDsData(kClr2)->Fill(Float_t(n)/(6*24));//(6*24) is the number of TRD time bins
+    }
+
+    Double_t p=track->GetP();
+
+    // Track related QA
+    if (track->IsOn(AliESDtrack::kTPCrefit)) {
+      Float_t dz[2]; 
+      track->GetDZ(0.,0.,0.,esd->GetMagneticField(),dz); 
+      if ((TMath::Abs(dz[0])<3.) && (TMath::Abs(dz[1])<3.)) { // beam pipe
+        Double_t phi=track->Phi();
+       GetESDsData(kTrk0)->Fill(phi);
+       Double_t y=track->Eta();
+       GetESDsData(kTrk1)->Fill(y);
+
+        if (TMath::Abs(y)<0.9) {
+          GetESDsData(kTrk2)->Fill(p);
+          if (track->IsOn(AliESDtrack::kITSrefit)) GetESDsData(kTrk3)->Fill(p);
+         //if (track->IsOn(AliESDtrack::kTOFout)) GetESDsData(kTrk4)->Fill(p);
+          if (track->GetTOFsignal()>0) GetESDsData(kTrk4)->Fill(p);
+       }
+      }
+    }
+    const AliExternalTrackParam *tpcTrack=track->GetTPCInnerParam();
+    const AliExternalTrackParam *innTrack=track->GetInnerParam();
+    if (tpcTrack)
+    if (innTrack) {
+       const AliESDVertex *vtx=esd->GetPrimaryVertex();
+       Double_t xv=vtx->GetXv();
+       Double_t yv=vtx->GetYv();
+       Double_t zv=vtx->GetZv();
+       Float_t dz[2];
+       tpcTrack->GetDZ(xv,yv,zv,esd->GetMagneticField(),dz);
+       dz[0]*=10.; // in mm
+       if (innTrack->GetZ()  > 0)
+       if (innTrack->GetTgl()> 0) { // TPC side A
+          if (tpcTrack->GetSign() > 0) GetESDsData(kTrk7)->Fill(dz[0]);
+          else                         GetESDsData(kTrk8)->Fill(dz[0]);
+       }
+       if (innTrack->GetZ()  < 0)
+       if (innTrack->GetTgl()< 0) { // TPC side C
+          if (tpcTrack->GetSign() > 0) GetESDsData(kTrk9)->Fill(dz[0]);
+          else                         GetESDsData(kTrk10)->Fill(dz[0]);
+       }
+    }
+
+    // PID related QA
+    if ((p>0.4) && (p<0.5)) {
+      if (track->IsOn(AliESDtrack::kITSpid)) {
+       Double_t dedx=track->GetITSsignal();
+        GetESDsData(kPid0)->Fill(dedx);
+      }
+      if (track->IsOn(AliESDtrack::kTPCpid)) {
+       Double_t dedx=track->GetTPCsignal();
+        GetESDsData(kPid1)->Fill(dedx);
+      }
+    }
+    if (p>1.0) {
+      if (track->IsOn(AliESDtrack::kTOFpid)) {
+        Double_t times[10];
+        track->GetIntegratedTimes(times);
+        Double_t tof=track->GetTOFsignal();
+        GetESDsData(kPid2)->Fill(times[2]-tof);
+      }
+    }
+    const AliExternalTrackParam *par=track->GetInnerParam();
+    if (par) {
+      Double_t pp=par->GetP();
+      Double_t dedx=track->GetTPCsignal();
+      TH2F *h = dynamic_cast<TH2F*>(GetESDsData(kPid3));
+      h->Fill(pp,dedx);
+    }
+  }
+
+  // V0 related QA
+  Int_t nV0=esd->GetNumberOfV0s();
+  for (Int_t i=0; i<nV0; i++) {
+    Double_t mass;
+    AliESDv0 v0(*esd->GetV0(i));
+
+    v0.ChangeMassHypothesis(kK0Short);
+    mass=v0.GetEffMass();
+    if (v0.GetOnFlyStatus())
+       GetESDsData(kK0on)->Fill(mass);
+    else
+       GetESDsData(kK0off)->Fill(mass);
+
+    v0.ChangeMassHypothesis(kLambda0);
+    mass=v0.GetEffMass();
+    if (v0.GetOnFlyStatus())
+       GetESDsData(kL0on)->Fill(mass);
+    else
+       GetESDsData(kL0off)->Fill(mass);
+
+    v0.ChangeMassHypothesis(kLambda0Bar);
+    mass=v0.GetEffMass();
+    if (v0.GetOnFlyStatus())
+       GetESDsData(kL0on)->Fill(mass);
+    else
+       GetESDsData(kL0off)->Fill(mass);
+  }
+
+  // Post output data.
+  PostData(1, fArrayQA);
+}      
+
+//________________________________________________________________________
+void AliAnalysisTaskGlobalQA::Terminate(Option_t *) 
+{
+  // Draw the results on the screen
+  // Called once at the end of the query
+
+  fArrayQA=(TObjArray*)GetOutputData(1);
+
+  TH1 *tpc=GetESDsData(kTrk2); tpc->Sumw2();
+  TH1 *its=GetESDsData(kTrk3); its->Sumw2();
+  TH1 *tof=GetESDsData(kTrk4); tof->Sumw2();
+  GetESDsData(kTrk5)->Divide(its,tpc,1,1.,"b");
+  GetESDsData(kTrk6)->Divide(tof,tpc,1,1.,"b");
+
+  TH1 *hTPCdEdxMIP = GetESDsData(kPid1);
+  if (!hTPCdEdxMIP) {
+    Printf("ERROR: hTPCdEdxMIP not available");
+    return;
+  }
+
+  TH2 *hTPCdEdxVsP = dynamic_cast<TH2*>(GetESDsData(kPid3));
+  if (!hTPCdEdxVsP) {
+    Printf("ERROR: hTPCdEdxVsP not available");
+    return;
+  }
+
+  TCanvas *c2=new TCanvas("c2","",320,32,530,590);
+
+  TPad *p6=new TPad("p6","",0.,0.,1.,.5); p6->Draw(); p6->cd(); 
+  p6->SetFillColor(42); p6->SetFrameFillColor(10);
+  hTPCdEdxMIP->SetFillColor(2); hTPCdEdxMIP->SetFillStyle(3005);
+  if (hTPCdEdxMIP->GetEntries()<333) 
+      hTPCdEdxMIP->DrawCopy("E"); 
+  else 
+      hTPCdEdxMIP->Fit("gaus"); 
+  c2->cd();
+
+  TPad *p7=new TPad("p7","",0.,0.5,1.,1.); p7->Draw(); p7->cd(); p7->SetLogx();
+  p7->SetFillColor(42); p7->SetFrameFillColor(10);
+  hTPCdEdxVsP->DrawCopy();
+
+}

diff --git a/PWG1/global/AliAnalysisTaskGlobalQA.h b/PWG1/global/AliAnalysisTaskGlobalQA.h
new file mode 100644 (file)
index 0000000..c1c28d4
--- /dev/null
+++ b/PWG1/global/AliAnalysisTaskGlobalQA.h
@@ -0,0 +1,43 @@
+#ifndef ALIANALYSISTASKGLOBALQA_H
+#define ALIANALYSISTASKGLOBALQA_H
+
+/*  See cxx source for full Copyright notice */
+
+//-----------------------------------------------------------------
+//                 AliAnalysisTaskGlobalQA class
+// This task is for running the GlobalQA over already existing ESDs
+//          Origin:  I.Belikov, Iouri.Belikov@cern.ch, June 2009
+//-----------------------------------------------------------------
+
+#include <TObjArray.h>
+#include "AliAnalysisTaskSE.h"
+
+class AliAnalysisTaskGlobalQA : public AliAnalysisTaskSE {
+public:
+  enum {
+    kClr0,kClr1,kClr2,
+    kTrk0,kTrk1,kTrk2,kTrk3,kTrk4,kTrk5,kTrk6,kTrk7,kTrk8,kTrk9,kTrk10,
+    kK0on,kK0off,kL0on,kL0off,
+    kPid0,kPid1,kPid2,kPid3,
+    kLast
+  };
+  AliAnalysisTaskGlobalQA();
+  virtual ~AliAnalysisTaskGlobalQA() {}
+  
+  virtual void   UserCreateOutputObjects();
+  virtual void   UserExec(Option_t *option);
+  virtual void   Terminate(Option_t *);
+  
+private:
+  void Add2ESDsList(TObject *o,Int_t index) {fArrayQA->AddAt(o,index);}
+  TH1 *GetESDsData(Int_t i) {return dynamic_cast<TH1*>(fArrayQA->At(i));}
+
+  TObjArray   *fArrayQA;       //! the array of output histos
+   
+  AliAnalysisTaskGlobalQA(const AliAnalysisTaskGlobalQA&);
+  AliAnalysisTaskGlobalQA& operator=(const AliAnalysisTaskGlobalQA&);
+  
+  ClassDef(AliAnalysisTaskGlobalQA, 1); // GlobalQA analysis
+};
+
+#endif

diff --git a/PWG1/macros/AddTaskGlobalQA.C b/PWG1/macros/AddTaskGlobalQA.C
new file mode 100644 (file)
index 0000000..1683504
--- /dev/null
+++ b/PWG1/macros/AddTaskGlobalQA.C
@@ -0,0 +1,30 @@
+AliAnalysisTaskGlobalQA *AddTaskGlobalQA()
+{
+   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+   if (!mgr) {
+      ::Error("AddTaskGlobalQA", "No analysis manager to connect to.");
+      return NULL;
+   }
+
+   AliAnalysisTaskGlobalQA *taskGlobalQA = new AliAnalysisTaskGlobalQA();
+   mgr->AddTask(taskGlobalQA);
+
+// Create ONLY the output containers for the data produced by the task.
+// Get and connect other common input/output containers via the manager as below
+//===========================================================================
+   TString outputFileName = AliAnalysisManager::GetCommonFileName();
+   outputFileName += ":PWG1GlobalQA";
+   if (lCollidingSystems) outputFileName += "_AA";
+   else outputFileName += "_PP";
+   if (mgr->GetMCtruthEventHandler()) outputFileName += "_MC";
+
+   AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("GlobalQA",
+                                                            TObjArray::Class(),
+                                                            AliAnalysisManager::kOutputContainer,
+                                                            outputFileName );
+
+   mgr->ConnectInput (taskGlobalQA, 0, mgr->GetCommonInputContainer());
+   mgr->ConnectOutput(taskGlobalQA, 1, coutput1);
+   return taskGlobalQA;
+}
+

diff --git a/PWG1/macros/runGlobalQA.C b/PWG1/macros/runGlobalQA.C
new file mode 100644 (file)
index 0000000..77d1411
--- /dev/null
+++ b/PWG1/macros/runGlobalQA.C
@@ -0,0 +1,91 @@
+void runLocal() {
+/*
+  gSystem->Load("libTree.so");
+  gSystem->Load("libGeom.so");
+  gSystem->Load("libVMC.so");
+  gSystem->Load("libPhysics.so");
+
+  gSystem->Load("libSTEERBase");
+  gSystem->Load("libESD");
+  gSystem->Load("libAOD");
+*/
+  gSystem->Load("libANALYSIS");
+  gSystem->Load("libANALYSISalice");
+  gSystem->Load("libTENDER");
+  gSystem->Load("libPWG1");
+
+  AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
+
+  
+  //gROOT->LoadMacro("AliAnalysisTaskGlobalQA.cxx++g");
+  AliAnalysisTask *task = new AliAnalysisTaskGlobalQA();
+  mgr->AddTask(task);
+  
+  AliESDInputHandler* esdH = new AliESDInputHandler;
+  mgr->SetInputEventHandler(esdH);
+  
+  AliMCEventHandler *mc = new AliMCEventHandler();
+  mgr->SetMCtruthEventHandler(mc);
+
+  gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C");
+  chain=CreateESDChain("list.txt",1);
+
+  // Create containers for input/output
+  mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
+
+  AliAnalysisDataContainer *coutput = 
+     mgr->CreateContainer("coutput", TObjArray::Class(),
+     AliAnalysisManager::kOutputContainer, "GlobalQA.root" );
+  mgr->ConnectOutput(task,1,coutput);
+
+  mgr->SetDebugLevel(0);
+  
+  if (!mgr->InitAnalysis()) return;
+  //mgr->PrintStatus();
+
+  mgr->StartAnalysis("local",chain);
+}
+
+void runProof() {
+    TProof::Open("belikov@localhost"); 
+  /*
+    gSystem->Load("libTree.so");
+    gSystem->Load("libGeom.so");
+    gSystem->Load("libVMC.so");
+    gSystem->Load("libPhysics.so");
+  */
+    gProof->UploadPackage("STEERBase");
+    gProof->EnablePackage("STEERBase");
+    gProof->UploadPackage("ESD");
+    gProof->EnablePackage("ESD");
+    gProof->UploadPackage("AOD");
+    gProof->EnablePackage("AOD");
+    gProof->UploadPackage("ANALYSIS");
+    gProof->EnablePackage("ANALYSIS");
+    gProof->UploadPackage("ANALYSISalice");
+    gProof->EnablePackage("ANALYSISalice");
+
+    gROOT->ProcessLine(".include $ALICE_ROOT/include");
+
+  AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
+
+  gProof->Load("$ALICE_ROOT/PWG1/global/AliAnalysisTaskGlobalQA.cxx++g");
+  AliAnalysisTask *task = new AliAnalysisTaskGlobalQA();
+  mgr->AddTask(task);
+  
+  AliESDInputHandler* esdH = new AliESDInputHandler;
+  mgr->SetInputEventHandler(esdH);
+  
+  mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
+
+  AliAnalysisDataContainer *coutput = 
+     mgr->CreateContainer("coutput", TObjArray::Class(),
+     AliAnalysisManager::kOutputContainer, "GlobalQA.root" );
+  mgr->ConnectOutput(task,1,coutput);
+
+  if (!mgr->InitAnalysis()) return;
+
+  mgr->StartAnalysis("proof","/COMMON/COMMON/LHC09d5_0.9TeV_0T",3000);
+
+}
+