added QA for cuts
authorsnelling <snelling@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 8 Nov 2010 22:37:21 +0000 (22:37 +0000)
committersnelling <snelling@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 8 Nov 2010 22:37:21 +0000 (22:37 +0000)
PWG2/FLOW/AliFlowTasks/AliAnalysisTaskQAflow.cxx [new file with mode: 0644]
PWG2/FLOW/AliFlowTasks/AliAnalysisTaskQAflow.h [new file with mode: 0644]
PWG2/FLOW/AliFlowTasks/AliFlowEventCuts.cxx
PWG2/FLOW/AliFlowTasks/AliFlowTrackCuts.cxx
PWG2/FLOW/AliFlowTasks/AliFlowTrackCuts.h
PWG2/PWG2flowTasksLinkDef.h
PWG2/libPWG2flowTasks.pkg

diff --git a/PWG2/FLOW/AliFlowTasks/AliAnalysisTaskQAflow.cxx b/PWG2/FLOW/AliFlowTasks/AliAnalysisTaskQAflow.cxx
new file mode 100644 (file)
index 0000000..ab2d543
--- /dev/null
@@ -0,0 +1,238 @@
+#include "TMath.h"
+#include "TH1D.h"
+#include "TH2D.h"
+#include "TSeqCollection.h"
+#include "TObjArray.h"
+#include "TObjArray.h"
+#include "TChain.h"
+#include "TMCProcess.h"
+#include "TLorentzVector.h"
+#include "TDirectory.h"
+#include "TROOT.h"
+
+#include "AliLog.h"
+#include "AliVParticle.h"
+#include "AliMCParticle.h"
+#include "AliStack.h"
+#include "AliVEvent.h"
+#include "AliESDEvent.h"
+#include "AliMCEvent.h"
+#include "AliESDtrack.h"
+#include "AliFlowTrackCuts.h"
+#include "AliFlowEventCuts.h"
+#include "AliMultiplicity.h"
+#include "AliESDtrackCuts.h"
+#include "AliVertex.h"
+
+#include "AliAnalysisTask.h"
+#include "AliAnalysisManager.h"
+
+#include "AliAnalysisTaskQAflow.h"
+
+ClassImp(AliAnalysisTaskQAflow)
+
+//________________________________________________________________________
+AliAnalysisTaskQAflow::AliAnalysisTaskQAflow()
+  : AliAnalysisTaskSE(),
+    fOutput(NULL),
+    fEventCuts(NULL),
+    fTrackCuts(NULL)
+{
+  // Default constructor
+}
+
+//________________________________________________________________________
+AliAnalysisTaskQAflow::AliAnalysisTaskQAflow(const char* name)
+  : AliAnalysisTaskSE(name),
+    fOutput(NULL),
+    fEventCuts(NULL),
+    fTrackCuts(NULL)
+{
+  // Constructor
+  DefineOutput(1, TObjArray::Class());
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskQAflow::UserCreateOutputObjects()
+{
+  // Called once at the beginning
+  fOutput=new TObjArray();
+  //TDirectory* before = gDirectory->mkdir("before cuts","before cuts");
+  //TDirectory* after = gDirectory->mkdir("after cuts","after cuts");
+  TObjArray* before = new TObjArray();
+  TObjArray* after = new TObjArray();
+  fOutput->Add(before);
+  fOutput->Add(after);
+
+  //define histograms
+
+  TH1* hist;  
+  hist = new TH1I("tracklet_multiplicity","tracklet multiplicity",1000,0,20000);
+  before->Add(hist); after->Add(hist->Clone()); //0
+  hist = new TH1I("track_multiplicity", "standard TPC track multiplicity",1000,0,10000);
+  before->Add(hist); after->Add(hist->Clone()); //1
+  hist = new TH1I("refmult","refmult",1000, 0,10000);
+  before->Add(hist); after->Add(hist->Clone()); //2
+  hist = new TH1I("SPD_clusters","SPD clusters",1000,0,100000);
+  before->Add(hist); after->Add(hist->Clone()); //3
+  hist = new TH1D("primary_vertexZ","primary vertex z",100,-20,20);
+  before->Add(hist); after->Add(hist->Clone()); //4
+  hist = new TH1I("ITS_clusters_on_track", "ITS clusters on track", 8, 0, 8);
+  before->Add(hist); after->Add(hist->Clone()); //5
+  hist = new TH1I("TPC_clusters_on_track", "TPC clusters on track", 159, 1, 160);
+  before->Add(hist); after->Add(hist->Clone()); //6
+  hist = new TH1D("TPC_chi2_per_cluster","TPC #chi^{2}/cluster",100,0.0,5.0);
+  before->Add(hist); after->Add(hist->Clone()); //7
+  hist = new TH1D("DCA_xy","DCA xy", 1000, -5.0, 5.0 );
+  before->Add(hist); after->Add(hist->Clone()); //8
+  hist = new TH1D("DCA_z","DCA z", 1000, -5.0, 5.0 );
+  before->Add(hist); after->Add(hist->Clone()); //9
+  hist = new TH1D("phi_tracklets","#phi tracklets", 1000, 0.0, TMath::TwoPi() );
+  before->Add(hist); after->Add(hist->Clone()); //10
+  hist = new TH1D("phi_tracks","#phi tracks", 1000, 0.0, TMath::TwoPi() );
+  before->Add(hist); after->Add(hist->Clone()); //11
+  hist = new TH1D("eta_tracklets","#eta tracklets", 1000, -2.0, 2.0 );
+  before->Add(hist); after->Add(hist->Clone()); //12
+  hist = new TH1D("eta_tracks","#eta tracks", 1000, -2.0, 2.0 );
+  before->Add(hist); after->Add(hist->Clone()); //13
+  hist = new TH1D("TPC_vertex_z", "TPC vertex z", 100,-20.0,20.0);
+  before->Add(hist); after->Add(hist->Clone()); //14
+  
+  //post data here as it doesn't change anyway (the pointer to list anyway)
+
+  //restore dir add status
+  PostData(1, fOutput);
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskQAflow::UserExec(Option_t *)
+{
+
+  //get teh input data
+  AliESDEvent* event = dynamic_cast<AliESDEvent*>(InputEvent());
+  if (!event)
+  {
+    AliFatal("no ESD event");
+    return;
+  }
+
+  //TObjArray* before = ((TDirectory*)fOutput->At(0))->GetList();
+  //TObjArray* after = ((TDirectory*)fOutput->At(1))->GetList();
+  TObjArray* before = (TObjArray*)fOutput->At(0);
+  TObjArray* after = (TObjArray*)fOutput->At(1);
+  TH1* htrackletmultB = dynamic_cast<TH1*>(before->At(0));
+  TH1* htrackletmultA = dynamic_cast<TH1*>(after->At(0));
+  TH1* htrackmultB = dynamic_cast<TH1*>(before->At(1));
+  TH1* htrackmultA = dynamic_cast<TH1*>(after->At(1));
+  TH1* hrefmultB = dynamic_cast<TH1*>(before->At(2));
+  TH1* hrefmultA = dynamic_cast<TH1*>(after->At(2));
+  TH1* hspdclustersB = dynamic_cast<TH1*>(before->At(3));
+  TH1* hspdclustersA = dynamic_cast<TH1*>(after->At(3));
+  TH1* hprimvtxzB = dynamic_cast<TH1*>(before->At(4));
+  TH1* hprimvtxzA = dynamic_cast<TH1*>(after->At(4));
+
+  TH1* hITSclsB = dynamic_cast<TH1*>(before->At(5));
+  TH1* hITSclsA = dynamic_cast<TH1*>(after->At(5));
+  TH1* hTPCclsB = dynamic_cast<TH1*>(before->At(6));
+  TH1* hTPCclsA = dynamic_cast<TH1*>(after->At(6));
+  TH1* hTPCchi2B = dynamic_cast<TH1*>(before->At(7));
+  TH1* hTPCchi2A = dynamic_cast<TH1*>(after->At(7));
+  TH1* hdcaxyB = dynamic_cast<TH1*>(before->At(8));
+  TH1* hdcaxyA = dynamic_cast<TH1*>(after->At(8));
+  TH1* hdcazB = dynamic_cast<TH1*>(before->At(9));
+  TH1* hdcazA = dynamic_cast<TH1*>(after->At(9));
+  TH1* hphitrackletsB = dynamic_cast<TH1*>(before->At(10));
+  TH1* hphitrackletsA = dynamic_cast<TH1*>(after->At(10));
+  TH1* hphitracksB = dynamic_cast<TH1*>(before->At(11));
+  TH1* hphitracksA = dynamic_cast<TH1*>(after->At(11));
+  TH1* hetatrackletsB = dynamic_cast<TH1*>(before->At(12));
+  TH1* hetatrackletsA = dynamic_cast<TH1*>(after->At(12));
+  TH1* hetatracksB = dynamic_cast<TH1*>(before->At(13));
+  TH1* hetatracksA = dynamic_cast<TH1*>(after->At(13));
+  TH1* hprimvtxzTPCB = dynamic_cast<TH1*>(before->At(14));
+  TH1* hprimvtxzTPCA = dynamic_cast<TH1*>(after->At(14));
+
+  AliMultiplicity* tracklets = const_cast<AliMultiplicity*>(event->GetMultiplicity());
+  Int_t ntracklets=0;
+  Int_t nspdclusters=0;
+  if (tracklets)
+  {
+    ntracklets = tracklets->GetNumberOfTracklets();
+    nspdclusters = tracklets->GetNumberOfITSClusters(0,1);
+    for (Int_t i=0; i<tracklets->GetNumberOfTracklets(); i++)
+    {
+      Bool_t pass=fTrackCuts->IsSelected(tracklets,i);
+      Float_t phi=tracklets->GetPhi(i);
+      Float_t eta=tracklets->GetEta(i);
+      hphitrackletsB->Fill(phi); if (pass) hphitrackletsA->Fill(phi);
+      hetatrackletsB->Fill(eta); if (pass) hetatrackletsA->Fill(eta); 
+    }
+    
+  }
+  Int_t trackmult = AliESDtrackCuts::GetReferenceMultiplicity(event,kTRUE);
+  Int_t refmult = fEventCuts->RefMult(event);
+  Bool_t passevent = fEventCuts->IsSelected(event);
+  htrackletmultB->Fill(ntracklets); if (passevent) htrackletmultA->Fill(ntracklets); 
+  htrackmultB->Fill(trackmult); if (passevent) htrackmultA->Fill( trackmult); 
+  hrefmultB->Fill(refmult); if (passevent) hrefmultA->Fill( refmult); 
+  hspdclustersB->Fill(nspdclusters); if (passevent) hspdclustersA->Fill( nspdclusters);
+  const AliVertex* vertex = event->GetPrimaryVertex();
+  Float_t vtxz=0.;
+  if (vertex)
+  {
+    vtxz = vertex->GetZ();
+    hprimvtxzB->Fill(vtxz); if (passevent) hprimvtxzA->Fill(vtxz);
+  }
+  const AliVertex* vertextpc = event->GetPrimaryVertexTPC();
+  if (vertextpc)
+  {
+    vtxz = vertextpc->GetZ();
+    hprimvtxzTPCB->Fill(vtxz); if (passevent) hprimvtxzTPCA->Fill(vtxz);
+  }
+  fTrackCuts->SetEvent(event);
+  for (Int_t i=0; i<fTrackCuts->GetNumberOfInputObjects(); i++)
+  {
+    TObject* obj = fTrackCuts->GetInputObject(i);
+    Bool_t pass = fTrackCuts->IsSelected(obj,i);
+    Float_t dcaxy=0.0;
+    Float_t dcaz=0.0;
+    Float_t tpcchi2=0.0;
+    Float_t tpcchi2percls=0.0;
+    Int_t ntpccls=0;
+    Int_t nitscls=0;
+    Float_t eta=0.0;
+    Float_t phi=0.0;
+    AliESDtrack* track = dynamic_cast<AliESDtrack*>(fTrackCuts->GetTrack());
+    if (track)
+    {
+      track->GetImpactParameters(dcaxy,dcaz);
+      tpcchi2=track->GetTPCchi2();
+      ntpccls=track->GetTPCNcls();
+      eta=track->Eta();
+      phi=track->Phi();
+      tpcchi2percls= (ntpccls==0)?0.0:tpcchi2/ntpccls;
+      nitscls = track->GetNcls(0);
+      hITSclsB->Fill(nitscls); if (pass) hITSclsA->Fill( nitscls);
+      hTPCclsB->Fill(ntpccls); if (pass) hTPCclsA->Fill( ntpccls);
+      hTPCchi2B->Fill(tpcchi2percls); if (pass) hTPCchi2A->Fill( tpcchi2percls);
+      hdcaxyB->Fill(dcaxy); if (pass) hdcaxyA->Fill( dcaxy);
+      hdcazB->Fill(dcaz); if (pass) hdcazA->Fill(dcaz);
+      hetatracksB->Fill(eta); if (pass) hetatracksA->Fill(eta);
+      hphitracksB->Fill(phi); if (pass) hphitracksA->Fill(phi);
+    }
+  }
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskQAflow::Terminate(Option_t *)
+{
+  
+}
+
+//________________________________________________________________________
+AliAnalysisTaskQAflow::~AliAnalysisTaskQAflow()
+{
+  //dtor
+  delete fTrackCuts;
+  delete fEventCuts;
+}
diff --git a/PWG2/FLOW/AliFlowTasks/AliAnalysisTaskQAflow.h b/PWG2/FLOW/AliFlowTasks/AliAnalysisTaskQAflow.h
new file mode 100644 (file)
index 0000000..2d35f26
--- /dev/null
@@ -0,0 +1,37 @@
+#ifndef ALIANALYSISTASKEFFICIENCYPRIMARIES_CXX
+#define ALIANALYSISTASKEFFICIENCYPRIMARIES_CXX
+
+class TObjArray;
+class AliESDEvent;
+class AliFlowEventCuts;
+class AliFlowTrackCuts;
+
+#include "AliAnalysisTaskSE.h"
+
+class AliAnalysisTaskQAflow: public AliAnalysisTaskSE
+{
+  public:
+    AliAnalysisTaskQAflow();
+    AliAnalysisTaskQAflow(const char* name);
+    virtual ~AliAnalysisTaskQAflow();
+    
+    virtual void UserCreateOutputObjects();
+    virtual void UserExec(Option_t *option);
+    virtual void Terminate(Option_t *);
+
+    void SetTrackCuts(AliFlowTrackCuts* trackcuts) {fTrackCuts=trackcuts;}
+    void SetEventCuts(AliFlowEventCuts* eventcuts) {fEventCuts=eventcuts;}
+  
+  private:
+    TObjArray* fOutput; //output histograms
+    AliFlowEventCuts* fEventCuts; //AliAnalysisCuts - applied before analysis - for comparing different event classes
+    AliFlowTrackCuts* fTrackCuts; //AliFlowTrackCuts go in here
+
+    AliAnalysisTaskQAflow(const AliAnalysisTaskQAflow&); // not implemented
+    AliAnalysisTaskQAflow& operator=(const AliAnalysisTaskQAflow&); // not implemented
+
+    ClassDef(AliAnalysisTaskQAflow, 2); // example of analysis 
+};
+
+#endif
+
index ff01f96..3a539d7 100644 (file)
@@ -201,51 +201,31 @@ AliFlowEventCuts* AliFlowEventCuts::StandardCuts()
 Int_t AliFlowEventCuts::RefMult(const AliVEvent* event)
 {
   //calculate the reference multiplicity, if all fails return 0
-  Int_t refmult=0;
-
-  //in the case of an ESD
-  const AliESDEvent* esd=dynamic_cast<const AliESDEvent*>(event);
-  if (esd) 
+  if (!fRefMultCuts)
   {
-    AliMultiplicity* tracklets=NULL;
     switch (fRefMultMethod)
     {
       case kTPConly:
-        if (!fRefMultCuts)
-        {
-          //if not explicitly passed, make default cuts
-          fRefMultCuts = AliFlowTrackCuts::GetStandardTPCOnlyTrackCuts();
-          fRefMultCuts->SetEtaRange(-0.8,0.8);
-          fRefMultCuts->SetPtMin(0.15);
-        }
-        for (Int_t i=0; i<esd->GetNumberOfTracks();i++)
-        {
-          AliESDtrack* track = esd->GetTrack(i);
-          if (fRefMultCuts->IsSelected(track)) refmult++;
-        }
+        fRefMultCuts = AliFlowTrackCuts::GetStandardTPCOnlyTrackCuts();
+        fRefMultCuts->SetEtaRange(-0.8,0.8);
+        fRefMultCuts->SetPtMin(0.15);
         break;
       case kSPDtracklets:
-        if (!fRefMultCuts)
-        {
-          //if not explicitly passed, make default fRefMultCuts
-          fRefMultCuts = new AliFlowTrackCuts();
-          fRefMultCuts->SetEtaRange(-0.8,0.8);
-        }
-        tracklets = const_cast<AliMultiplicity*>(esd->GetMultiplicity());
-        for (Int_t i=0; i<tracklets->GetNumberOfTracklets(); i++)
-        {
-          if (fRefMultCuts->IsSelected(tracklets,i)) refmult++;
-        }
+        fRefMultCuts = new AliFlowTrackCuts();
+        fRefMultCuts->SetParamType(AliFlowTrackCuts::kESD_SPDtracklet);
+        fRefMultCuts->SetEtaRange(-0.8,0.8);
         break;
       default:
         return 0;
     }
-    return refmult;
   }
 
-  //in case of MC event
-  AliMCEvent* mc=const_cast<AliMCEvent*>(dynamic_cast<const AliMCEvent*>(event));
-  if (mc) return mc->GetNumberOfPrimaries();
-
-  return event->GetNumberOfTracks(); //default, at least returns some number
+  fRefMultCuts->SetEvent(const_cast<AliVEvent*>(event));
+  Int_t refmult=0;
+  for (Int_t i=0; i<fRefMultCuts->GetNumberOfInputObjects(); i++)
+  {
+    if (fRefMultCuts->IsSelected(fRefMultCuts->GetInputObject(i),i))
+      refmult++;
+  }
+  return refmult;
 }
index 3e92f87..ea075d8 100644 (file)
@@ -37,6 +37,7 @@
 #include <limits.h>
 #include <float.h>
 #include "TParticle.h"
+#include "TObjArray.h"
 #include "AliStack.h"
 #include "AliMCEvent.h"
 #include "AliESDEvent.h"
@@ -72,6 +73,9 @@ AliFlowTrackCuts::AliFlowTrackCuts():
   fIgnoreTPCzRange(kFALSE),
   fIgnoreTPCzRangeMax(FLT_MAX),
   fIgnoreTPCzRangeMin(-FLT_MAX),
+  fCutChi2PerClusterTPC(kFALSE),
+  fMaxChi2PerClusterTPC(FLT_MAX),
+  fMinChi2PerClusterTPC(-FLT_MAX),
   fParamType(kGlobal),
   fParamMix(kPure),
   fTrack(NULL),
@@ -108,6 +112,9 @@ AliFlowTrackCuts::AliFlowTrackCuts(const AliFlowTrackCuts& that):
   fIgnoreTPCzRange(that.fIgnoreTPCzRange),
   fIgnoreTPCzRangeMax(that.fIgnoreTPCzRangeMax),
   fIgnoreTPCzRangeMin(that.fIgnoreTPCzRangeMin),
+  fCutChi2PerClusterTPC(that.fCutChi2PerClusterTPC),
+  fMaxChi2PerClusterTPC(that.fMaxChi2PerClusterTPC),
+  fMinChi2PerClusterTPC(that.fMinChi2PerClusterTPC),
   fParamType(that.fParamType),
   fParamMix(that.fParamMix),
   fTrack(NULL),
@@ -146,6 +153,9 @@ AliFlowTrackCuts& AliFlowTrackCuts::operator=(const AliFlowTrackCuts& that)
   fIgnoreTPCzRange=that.fIgnoreTPCzRange;
   fIgnoreTPCzRangeMax=that.fIgnoreTPCzRangeMax;
   fIgnoreTPCzRangeMin=that.fIgnoreTPCzRangeMin;
+  fCutChi2PerClusterTPC=that.fCutChi2PerClusterTPC;
+  fMaxChi2PerClusterTPC=that.fMaxChi2PerClusterTPC;
+  fMinChi2PerClusterTPC=that.fMinChi2PerClusterTPC;
   fParamType=that.fParamType;
   fParamMix=that.fParamMix;
 
@@ -312,6 +322,7 @@ Bool_t AliFlowTrackCuts::PassesCuts(AliVParticle* vparticle)
   ////////////////////////////////////////////////////////////////
 
   if (!fTrack) return kFALSE;
+  
   Bool_t pass=kTRUE;
   //check the common cuts for the current particle fTrack (MC,AOD,ESD)
   if (fCutPt) {if (fTrack->Pt() < fPtMin || fTrack->Pt() >= fPtMax ) pass=kFALSE;}
@@ -347,6 +358,15 @@ Bool_t AliFlowTrackCuts::PassesCuts(AliVParticle* vparticle)
       }
     }
     if (!fAliESDtrackCuts->IsSelected(static_cast<AliESDtrack*>(fTrack))) pass=kFALSE;
+    if (fCutChi2PerClusterTPC)
+    {
+      Float_t tpcchi2 = (fParamType==kESD_TPConly)?
+                         esdTrack->GetTPCchi2Iter1():esdTrack->GetTPCchi2();
+      Int_t ntpccls = esdTrack->GetTPCNcls();
+      tpcchi2 = (ntpccls>0)?tpcchi2/ntpccls:-FLT_MAX;
+      if (tpcchi2<fMinChi2PerClusterTPC || tpcchi2 >=fMaxChi2PerClusterTPC)
+        pass=kFALSE;
+    }
   }
 
   return pass; //true by default, if we didn't set any cuts
index 76c3412..02ba91b 100644 (file)
@@ -14,7 +14,7 @@
 #include "TMCProcess.h"
 #include "AliESDtrack.h"
 
-class TDirectory;
+class TObjArray;
 class AliVParticle;
 class AliMCParticle;
 class AliFlowTrack;
@@ -42,7 +42,8 @@ class AliFlowTrackCuts : public AliFlowTrackSimpleCuts {
   void SetClusterRequirementITS( AliESDtrackCuts::Detector det,
                                  AliESDtrackCuts::ITSClusterRequirement req = AliESDtrackCuts::kOff )
                                  { fAliESDtrackCuts->SetClusterRequirementITS(det,req); } 
-  void SetMaxChi2PerClusterTPC( Float_t a ) {fAliESDtrackCuts->SetMaxChi2PerClusterTPC(a);}
+  void SetMaxChi2PerClusterTPC( Float_t a ) {fMaxChi2PerClusterTPC=a;fCutChi2PerClusterTPC=kTRUE;}
+  void SetMinChi2PerClusterTPC( Float_t a ) {fMinChi2PerClusterTPC=a;fCutChi2PerClusterTPC=kTRUE;}
   void SetMaxChi2PerClusterITS( Float_t a ) {fAliESDtrackCuts->SetMaxChi2PerClusterITS(a);}
   void SetRequireTPCRefit( Bool_t a ) {fAliESDtrackCuts->SetRequireTPCRefit(a);}
   void SetRequireTPCStandAlone( Bool_t a) {fAliESDtrackCuts->SetRequireTPCStandAlone(a);}
@@ -90,7 +91,7 @@ class AliFlowTrackCuts : public AliFlowTrackSimpleCuts {
   Double_t GetSPDtrackletDeltaPhiMin() const {return fSPDtrackletDeltaPhiMin;}
 
   void SetQA(const char* dirname);
-  TDirectory* GetQA() const {return fQA;}
+  TObjArray* GetQA() const {return fQA;}
 
   //MC stuff
   void SetCutMC( Bool_t b=kTRUE ) {fCutMC=b;}
@@ -134,7 +135,7 @@ class AliFlowTrackCuts : public AliFlowTrackSimpleCuts {
 
   //the cuts
   AliESDtrackCuts* fAliESDtrackCuts; //alianalysis cuts
-  TDirectory* fQA;                   //qa histograms go here
+  TObjArray* fQA;                   //qa histograms go here
   Bool_t fCutMC;                     //do we cut on MC?
   Bool_t fCutMCprocessType;          //do we cut on mc process type?
   TMCProcess fMCprocessType;         //mc process type
@@ -151,6 +152,9 @@ class AliFlowTrackCuts : public AliFlowTrackSimpleCuts {
   Bool_t fIgnoreTPCzRange;   //ignore tracks going close to central membrane
   Double_t fIgnoreTPCzRangeMax; //max z to ignore
   Double_t fIgnoreTPCzRangeMin; //min z to ignore
+  Bool_t fCutChi2PerClusterTPC; //cut on tpc chi2
+  Float_t fMaxChi2PerClusterTPC; //max chi2 tpc/cluster
+  Float_t fMinChi2PerClusterTPC; //min chi2 tpc/cluster
 
   trackParameterType fParamType;     //parameter type tu cut on
   trackParameterMix fParamMix;       //parameter mixing
index 19e973e..aa81e72 100644 (file)
@@ -21,5 +21,6 @@
 #pragma link C++ class AliAnalysisTaskFlowEventforRP+;
 #pragma link C++ class AliAnalysisTaskMixedHarmonics+;
 #pragma link C++ class AliAnalysisTaskNestedLoops+;
+#pragma link C++ class AliAnalysisTaskQAflow+;
 
 #endif
index 85b0a27..fdcd704 100644 (file)
@@ -15,7 +15,8 @@ SRCS= FLOW/AliFlowTasks/AliFlowEventSimpleMaker.cxx \
       FLOW/AliFlowTasks/AliAnalysisTaskFlowEvent.cxx \
       FLOW/AliFlowTasks/AliAnalysisTaskFlowEventforRP.cxx \
       FLOW/AliFlowTasks/AliAnalysisTaskMixedHarmonics.cxx \
-      FLOW/AliFlowTasks/AliAnalysisTaskNestedLoops.cxx 
+      FLOW/AliFlowTasks/AliAnalysisTaskNestedLoops.cxx \
+      FLOW/AliFlowTasks/AliAnalysisTaskQAflow.cxx
 
 HDRS= $(SRCS:.cxx=.h)