added new enum that describes the type of analysis, passed to all analysis classes
authorjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 21 Jan 2008 11:09:54 +0000 (11:09 +0000)
committerjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 21 Jan 2008 11:09:54 +0000 (11:09 +0000)
added macro for standard cuts in base dir

19 files changed:
PWG0/AliCorrection.cxx
PWG0/AliCorrection.h
PWG0/AliPWG0Helper.cxx
PWG0/AliPWG0Helper.h
PWG0/CreateStandardCuts.C [new file with mode: 0644]
PWG0/dNdEta/AlidNdEtaCorrection.cxx
PWG0/dNdEta/AlidNdEtaCorrection.h
PWG0/dNdEta/AlidNdEtaCorrectionTask.cxx
PWG0/dNdEta/AlidNdEtaCorrectionTask.h
PWG0/dNdEta/AlidNdEtaTask.cxx
PWG0/dNdEta/AlidNdEtaTask.h
PWG0/dNdEta/CreateCuts.C [deleted file]
PWG0/dNdEta/dNdEtaAnalysis.cxx
PWG0/dNdEta/dNdEtaAnalysis.h
PWG0/dNdEta/drawPlots.C
PWG0/dNdEta/drawSystematics.C
PWG0/dNdEta/run.C
PWG0/dNdEta/runCorrection.C
PWG0/esdTrackCuts/AliESDtrackCuts.h

index 22044fa..bd551d5 100644 (file)
@@ -30,7 +30,7 @@ AliCorrection::AliCorrection() : TNamed(),
 }
 
 //____________________________________________________________________
-AliCorrection::AliCorrection(const Char_t* name, const Char_t* title, const char* analysis) : TNamed(name, title),
+AliCorrection::AliCorrection(const Char_t* name, const Char_t* title, AliPWG0Helper::AnalysisMode analysisMode) : TNamed(name, title),
   fEventCorr(0),
   fTrackCorr(0)
 {
@@ -40,12 +40,13 @@ AliCorrection::AliCorrection(const Char_t* name, const Char_t* title, const char
   Int_t nBinsPt = 0;
 
   // different binnings, better solution could be anticipated...
-  if (TString(analysis).CompareTo("tpc", TString::kIgnoreCase) == 0)
+  if (analysisMode == AliPWG0Helper::kTPC || analysisMode == AliPWG0Helper::kTPCITS)
   {
     static Float_t binLimitsPtTmp[] = {0.0, 0.05, 0.1, 0.125, 0.15, 0.175, 0.2, 0.225, 0.25, 0.275, 0.3, 0.325, 0.35, 0.375, 0.4, 0.425, 0.45, 0.475, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.5, 2.0, 5.0, 10.0, 100.0};
     binLimitsPt = (Float_t*) binLimitsPtTmp;
     nBinsPt = 28;
-  } else if (TString(analysis).CompareTo("spd", TString::kIgnoreCase) == 0)
+  } 
+  else if (analysisMode == AliPWG0Helper::kSPD)
   {
     static Float_t binLimitsPtTmp[] = {-0.5, 0.5};
     binLimitsPt = (Float_t*) binLimitsPtTmp;
index 84b8d78..845c48e 100644 (file)
@@ -14,6 +14,7 @@
 // ------------------------------------------------------
 
 #include <TNamed.h>
+#include "AliPWG0Helper.h"
 
 class AliCorrectionMatrix2D;
 class AliCorrectionMatrix3D;
@@ -22,7 +23,7 @@ class AliCorrection : public TNamed
 {
 public:
   AliCorrection();
-  AliCorrection(const Char_t* name, const Char_t* title, const char* analysis = "tpc");
+  AliCorrection(const Char_t* name, const Char_t* title, AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kTPC);
   AliCorrection(const AliCorrection& c);
 
   virtual ~AliCorrection();
index 7377dbb..0b06b09 100644 (file)
@@ -18,6 +18,7 @@
 
 #include <AliLog.h>
 #include <AliESD.h>
+#include <AliESDEvent.h>
 #include <AliESDVertex.h>
 
 #include <AliGenEventHeader.h>
@@ -107,6 +108,45 @@ Bool_t AliPWG0Helper::IsVertexReconstructed(const AliESDVertex* vtxESD)
 }
 
 //____________________________________________________________________
+const AliESDVertex* AliPWG0Helper::GetVertex(const AliESDEvent* aEsd, AnalysisMode analysisMode)
+{
+  // Get the vertex from the ESD and returns it if the vertex is valid
+  //
+  // Second argument decides which vertex is used (this selects
+  // also the quality criteria that are applied)
+
+  const AliESDVertex* vertex = 0;
+  Float_t requiredZResolution = -1;
+  if (analysisMode == kSPD || analysisMode == kTPCITS)
+  {
+    vertex = aEsd->GetVertex();
+    requiredZResolution = 0.1;
+  }
+  else if (analysisMode == kTPC) 
+  {
+    vertex = aEsd->GetPrimaryVertex();
+    requiredZResolution = 0.6;
+  }
+  else
+    Printf("AliPWG0Helper::GetVertex: ERROR: Invalid second argument %d", analysisMode);
+
+  if (!vertex)
+    return 0;
+
+  // check Ncontributors
+  if (vertex->GetNContributors() <= 0)
+    return 0;
+
+  // check resolution
+  Double_t zRes = vertex->GetZRes();
+
+  if (zRes == 0 || zRes > requiredZResolution)
+    return 0;
+
+  return vertex;
+}
+
+//____________________________________________________________________
 Bool_t AliPWG0Helper::IsPrimaryCharged(TParticle* aParticle, Int_t aTotalPrimaries, Bool_t adebug)
 {
   //
index 5e9fdc2..f14cb28 100644 (file)
@@ -8,6 +8,7 @@
 // static helper functions
 
 class AliESD;
+class AliESDEvent;
 class AliESDVertex;
 class TParticle;
 class TH1;
@@ -21,11 +22,14 @@ class AliPWG0Helper : public TObject
 {
   public:
     enum Trigger { kMB1 = 0, kMB2 }; // definition from ALICE-INT-2005-025
+    enum AnalysisMode { kSPD = 0, kTPC, kTPCITS };
 
     static Bool_t IsEventTriggered(const AliESD* aEsd, Trigger trigger = kMB2);
     static Bool_t IsEventTriggered(ULong64_t triggerMask, Trigger trigger = kMB2);
     static Bool_t IsVertexReconstructed(const AliESD* aEsd);
     static Bool_t IsVertexReconstructed(const AliESDVertex* vtxESD);
+    static const AliESDVertex* GetVertex(const AliESDEvent* aEsd, AnalysisMode analysisMethod);
+
     static Bool_t IsPrimaryCharged(TParticle* aParticle, Int_t aTotalPrimaries, Bool_t adebug = kFALSE);
 
     static Int_t GetPythiaEventProcessType(AliHeader* aHeader, Bool_t adebug = kFALSE);
diff --git a/PWG0/CreateStandardCuts.C b/PWG0/CreateStandardCuts.C
new file mode 100644 (file)
index 0000000..c801069
--- /dev/null
@@ -0,0 +1,54 @@
+/* $Id: CreateCuts.C,v 1.5 2008/01/11 08:28:52 jgrosseo Exp $ */
+
+// this macro creates the track and event cuts used in this analysis
+
+AliESDtrackCuts* CreateTrackCuts(AliPWG0Helper::AnalysisMode analysisMode, Bool_t fieldOn = kTRUE, Bool_t hists = kTRUE)
+{
+  AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts("AliESDtrackCuts");
+
+  if (hists)
+    esdTrackCuts->DefineHistograms(1);
+
+  // default cuts for ITS+TPC
+  Double_t cov1 = 2;
+  Double_t cov2 = 2;
+  Double_t cov3 = 0.5;
+  Double_t cov4 = 0.5;
+  Double_t cov5 = 2;
+  Double_t nSigma = 3;
+
+  TString tag("Global tracking");
+
+  // TPC-only cuts
+  if (analysisMode == AliPWG0Helper::kTPC) 
+  {
+    // beta cuts (still under investigation)
+    cov1 = 4;
+    cov2 = 4;
+    nSigma = 4;
+    
+    tag = "TPC-only tracking";
+  }
+
+  // cuts for data without field
+  if (!fieldOn)
+  {
+    cov5 = 1e10;
+    tag += " without field";
+  }
+  
+  esdTrackCuts->SetMaxCovDiagonalElements(cov1, cov2, cov3, cov4, cov5);
+
+  esdTrackCuts->SetMinNsigmaToVertex(nSigma);
+  esdTrackCuts->SetRequireSigmaToVertex(kTRUE);
+
+  esdTrackCuts->SetRequireTPCRefit(kTRUE);
+  esdTrackCuts->SetAcceptKingDaughters(kFALSE);
+
+  esdTrackCuts->SetMinNClustersTPC(50);
+  esdTrackCuts->SetMaxChi2PerClusterTPC(3.5);
+
+  Printf("Created track cuts for: %s", tag.Data());
+
+  return esdTrackCuts;
+}
index 39f8a32..261d339 100644 (file)
@@ -42,7 +42,7 @@ AlidNdEtaCorrection::AlidNdEtaCorrection()
 }
 
 //____________________________________________________________________
-AlidNdEtaCorrection::AlidNdEtaCorrection(const Char_t* name, const Char_t* title, const char* analysis)
+AlidNdEtaCorrection::AlidNdEtaCorrection(const Char_t* name, const Char_t* title, AliPWG0Helper::AnalysisMode analysis)
   : TNamed(name, title),
   fTrack2ParticleCorrection(0),
   fVertexRecoCorrection(0),
index 59502ff..6a9a704 100644 (file)
@@ -20,6 +20,7 @@
 
 #include <TCollection.h>
 #include <TNamed.h>
+#include "AliPWG0Helper.h"
 
 class AliCorrection;
 
@@ -36,7 +37,7 @@ public:
   };
 
   AlidNdEtaCorrection();
-  AlidNdEtaCorrection(const Char_t* name, const Char_t* title, const char* analysis = "TPC");
+  AlidNdEtaCorrection(const Char_t* name, const Char_t* title, AliPWG0Helper::AnalysisMode analysis = AliPWG0Helper::kTPC);
 
   virtual Long64_t Merge(TCollection* list);
 
index 5b7a9d0..ae21d29 100644 (file)
@@ -34,7 +34,7 @@ AlidNdEtaCorrectionTask::AlidNdEtaCorrectionTask(const char* opt) :
   fESD(0),
   fOutput(0),
   fOption(opt),
-  fAnalysisMode(kTPC),
+  fAnalysisMode(AliPWG0Helper::kTPC),
   fSignMode(0),
   fEsdTrackCuts(0),
   fdNdEtaCorrection(0),
@@ -89,11 +89,12 @@ void AlidNdEtaCorrectionTask::ConnectInputData(Option_t *)
 
     tree->SetBranchStatus("fTriggerMask", 1);
     tree->SetBranchStatus("fSPDVertex*", 1);
+    // PrimaryVertex
 
-    if (fAnalysisMode == kSPD)
+    if (fAnalysisMode == AliPWG0Helper::kSPD)
       tree->SetBranchStatus("fSPDMult*", 1);
 
-    if (fAnalysisMode == kTPC) {
+    if (fAnalysisMode == AliPWG0Helper::kTPC || fAnalysisMode == AliPWG0Helper::kTPCITS) {
       AliESDtrackCuts::EnableNeededBranches(tree);
       tree->SetBranchStatus("fTracks.fLabel", 1);
     }
@@ -125,18 +126,10 @@ void AlidNdEtaCorrectionTask::CreateOutputObjects()
     fSignMode = -1;
   }
 
-  TString detector;
-  if (fAnalysisMode == kTPC)
-  {
-    detector = "TPC";
-  }
-  else if (fAnalysisMode == kSPD)
-    detector = "SPD";
-
   fOutput = new TList;
   fOutput->SetOwner();
 
-  fdNdEtaCorrection = new AlidNdEtaCorrection("dndeta_correction", "dndeta_correction", detector);
+  fdNdEtaCorrection = new AlidNdEtaCorrection("dndeta_correction", "dndeta_correction", fAnalysisMode);
   fOutput->Add(fdNdEtaCorrection);
 
   fPIDParticles = new TH1F("pid_particles", "PID of generated primary particles", 10001, -5000.5, 5000.5);
@@ -145,10 +138,10 @@ void AlidNdEtaCorrectionTask::CreateOutputObjects()
   fPIDTracks = new TH1F("pid_tracks", "MC PID of reconstructed tracks", 10001, -5000.5, 5000.5);
   fOutput->Add(fPIDTracks);
 
-  fdNdEtaAnalysisMC = new dNdEtaAnalysis("dndetaMC", "dndetaMC", detector);
+  fdNdEtaAnalysisMC = new dNdEtaAnalysis("dndetaMC", "dndetaMC", fAnalysisMode);
   fOutput->Add(fdNdEtaAnalysisMC);
 
-  fdNdEtaAnalysisESD = new dNdEtaAnalysis("dndetaESD", "dndetaESD", detector);
+  fdNdEtaAnalysisESD = new dNdEtaAnalysis("dndetaESD", "dndetaESD", fAnalysisMode);
   fOutput->Add(fdNdEtaAnalysisESD);
 
   if (fOption.Contains("process-types")) {
@@ -185,7 +178,9 @@ void AlidNdEtaCorrectionTask::Exec(Option_t*)
   // trigger definition
   Bool_t eventTriggered = AliPWG0Helper::IsEventTriggered(fESD->GetTriggerMask(), AliPWG0Helper::kMB1);
 
-  Bool_t eventVertex = AliPWG0Helper::IsVertexReconstructed(fESD->GetVertex());
+  Bool_t eventVertex = kFALSE;
+  if (AliPWG0Helper::GetVertex(fESD, fAnalysisMode))
+    eventVertex = kTRUE;
 
   // post the data already here
   PostData(0, fOutput);
@@ -195,7 +190,7 @@ void AlidNdEtaCorrectionTask::Exec(Option_t*)
   Int_t* labelArr = 0;
   Float_t* etaArr = 0;
   Float_t* ptArr = 0;
-  if (fAnalysisMode == kSPD)
+  if (fAnalysisMode == AliPWG0Helper::kSPD)
   {
     // get tracklets
     const AliMultiplicity* mult = fESD->GetMultiplicity();
@@ -224,7 +219,7 @@ void AlidNdEtaCorrectionTask::Exec(Option_t*)
       ++inputCount;
     }
   }
-  else if (fAnalysisMode == kTPC)
+  else if (fAnalysisMode == AliPWG0Helper::kTPC || fAnalysisMode == AliPWG0Helper::kTPCITS)
   {
     if (!fEsdTrackCuts)
     {
index 22348f3..c9419e4 100644 (file)
@@ -5,6 +5,7 @@
 
 #include "AliAnalysisTask.h"
 #include <TString.h>
+#include "AliPWG0Helper.h"
 
 class AliESDtrackCuts;
 class dNdEtaAnalysis;
@@ -15,8 +16,6 @@ class TParticlePDG;
 
 class AlidNdEtaCorrectionTask : public AliAnalysisTask {
   public:
-    enum AnalysisMethod { kSPD = 0, kTPC };
-
     AlidNdEtaCorrectionTask(const char* opt = "");
     virtual ~AlidNdEtaCorrectionTask();
 
@@ -26,7 +25,7 @@ class AlidNdEtaCorrectionTask : public AliAnalysisTask {
     virtual void   Terminate(Option_t *);
 
     void SetTrackCuts(AliESDtrackCuts* cuts) { fEsdTrackCuts = cuts; }
-    void SetAnalysisMode(AnalysisMethod mode) { fAnalysisMode = mode; }
+    void SetAnalysisMode(AliPWG0Helper::AnalysisMode mode) { fAnalysisMode = mode; }
 
  protected:
     Bool_t SignOK(TParticlePDG* particle);
@@ -35,7 +34,7 @@ class AlidNdEtaCorrectionTask : public AliAnalysisTask {
     TList* fOutput;                  //! list send on output slot 0
 
     TString fOption;                 // option string
-    AnalysisMethod fAnalysisMode;    // detector that is used for analysis
+    AliPWG0Helper::AnalysisMode fAnalysisMode;    // detector that is used for analysis
     Int_t fSignMode;                 // if 0 process all particles, if +-1 process only particles with that sign
 
     AliESDtrackCuts*  fEsdTrackCuts;             // Object containing the parameters of the esd track cuts
index 7a77952..7e21a1f 100644 (file)
@@ -42,7 +42,7 @@ AlidNdEtaTask::AlidNdEtaTask(const char* opt) :
   fESD(0),
   fOutput(0),
   fOption(opt),
-  fAnalysisMode(kTPC),
+  fAnalysisMode(AliPWG0Helper::kTPC),
   fReadMC(kFALSE),
   fEsdTrackCuts(0),
   fdNdEtaAnalysisESD(0),
@@ -97,11 +97,12 @@ void AlidNdEtaTask::ConnectInputData(Option_t *)
 
     tree->SetBranchStatus("fTriggerMask", 1);
     tree->SetBranchStatus("fSPDVertex*", 1);
+    // PrimaryVertex also needed
 
-    if (fAnalysisMode == kSPD)
+    if (fAnalysisMode == AliPWG0Helper::kSPD)
       tree->SetBranchStatus("fSPDMult*", 1);
 
-    if (fAnalysisMode == kTPC) {
+    if (fAnalysisMode == AliPWG0Helper::kTPC || fAnalysisMode == AliPWG0Helper::kTPCITS) {
       AliESDtrackCuts::EnableNeededBranches(tree);
       tree->SetBranchStatus("fTracks.fLabel", 1);
     }
@@ -122,15 +123,7 @@ void AlidNdEtaTask::CreateOutputObjects()
   fOutput = new TList;
   fOutput->SetOwner();
 
-  TString detector;
-  if (fAnalysisMode == kTPC)
-  {
-    detector = "TPC";
-  }
-  else if (fAnalysisMode == kSPD)
-    detector = "SPD";
-
-  fdNdEtaAnalysisESD = new dNdEtaAnalysis("fdNdEtaAnalysisESD", "fdNdEtaAnalysisESD", detector);
+  fdNdEtaAnalysisESD = new dNdEtaAnalysis("fdNdEtaAnalysisESD", "fdNdEtaAnalysisESD", fAnalysisMode);
   fOutput->Add(fdNdEtaAnalysisESD);
 
   fMult = new TH1F("fMult", "fMult;Ntracks;Count", 201, -0.5, 200.5);
@@ -151,16 +144,16 @@ void AlidNdEtaTask::CreateOutputObjects()
 
   if (fReadMC)
   {
-    fdNdEtaAnalysis = new dNdEtaAnalysis("dndeta", "dndeta", detector);
+    fdNdEtaAnalysis = new dNdEtaAnalysis("dndeta", "dndeta", fAnalysisMode);
     fOutput->Add(fdNdEtaAnalysis);
 
-    fdNdEtaAnalysisTr = new dNdEtaAnalysis("dndetaTr", "dndetaTr", detector);
+    fdNdEtaAnalysisTr = new dNdEtaAnalysis("dndetaTr", "dndetaTr", fAnalysisMode);
     fOutput->Add(fdNdEtaAnalysisTr);
 
-    fdNdEtaAnalysisTrVtx = new dNdEtaAnalysis("dndetaTrVtx", "dndetaTrVtx", detector);
+    fdNdEtaAnalysisTrVtx = new dNdEtaAnalysis("dndetaTrVtx", "dndetaTrVtx", fAnalysisMode);
     fOutput->Add(fdNdEtaAnalysisTrVtx);
 
-    fdNdEtaAnalysisTracks = new dNdEtaAnalysis("dndetaTracks", "dndetaTracks", detector);
+    fdNdEtaAnalysisTracks = new dNdEtaAnalysis("dndetaTracks", "dndetaTracks", fAnalysisMode);
     fOutput->Add(fdNdEtaAnalysisTracks);
 
     fVertex = new TH3F("vertex_check", "vertex_check", 50, -50, 50, 50, -50, 50, 50, -50, 50);
@@ -186,12 +179,12 @@ void AlidNdEtaTask::Exec(Option_t*)
   // trigger definition
   Bool_t eventTriggered = AliPWG0Helper::IsEventTriggered(fESD->GetTriggerMask(), AliPWG0Helper::kMB2);
 
-  Bool_t eventVertex = AliPWG0Helper::IsVertexReconstructed(fESD->GetVertex());
-
   // get the ESD vertex
-  const AliESDVertex* vtxESD = fESD->GetVertex();
+  const AliESDVertex* vtxESD = AliPWG0Helper::GetVertex(fESD, fAnalysisMode);
+  
   Double_t vtx[3];
-  vtxESD->GetXYZ(vtx);
+  if (vtxESD)
+    vtxESD->GetXYZ(vtx);
 
   // post the data already here
   PostData(0, fOutput);
@@ -201,7 +194,7 @@ void AlidNdEtaTask::Exec(Option_t*)
   Int_t* labelArr = 0;
   Float_t* etaArr = 0;
   Float_t* ptArr = 0;
-  if (fAnalysisMode == kSPD)
+  if (fAnalysisMode == AliPWG0Helper::kSPD)
   {
     // get tracklets
     const AliMultiplicity* mult = fESD->GetMultiplicity();
@@ -230,7 +223,7 @@ void AlidNdEtaTask::Exec(Option_t*)
       ++inputCount;
     }
   }
-  else if (fAnalysisMode == kTPC)
+  else if (fAnalysisMode == AliPWG0Helper::kTPC || fAnalysisMode == AliPWG0Helper::kTPCITS)
   {
     if (!fEsdTrackCuts)
     {
@@ -260,8 +253,6 @@ void AlidNdEtaTask::Exec(Option_t*)
       labelArr[inputCount] = TMath::Abs(esdTrack->GetLabel());
       ptArr[inputCount] = esdTrack->Pt();
       ++inputCount;
-
-      Printf("%f", esdTrack->Pt());
     }
   }
   else
@@ -272,7 +263,7 @@ void AlidNdEtaTask::Exec(Option_t*)
   {
     // control hist
     fMult->Fill(inputCount);
-    if (eventVertex)
+    if (vtxESD)
     {
       // control hist
       fMultVtx->Fill(inputCount);
@@ -364,7 +355,7 @@ void AlidNdEtaTask::Exec(Option_t*)
       if (eventTriggered)
       {
         fdNdEtaAnalysisTr->FillTrack(vtxMC[2], eta, pt);
-        if (eventVertex)
+        if (vtxESD)
           fdNdEtaAnalysisTrVtx->FillTrack(vtxMC[2], eta, pt);
       }
 
@@ -376,11 +367,11 @@ void AlidNdEtaTask::Exec(Option_t*)
     if (eventTriggered)
     {
       fdNdEtaAnalysisTr->FillEvent(vtxMC[2], nAcceptedParticles);
-      if (eventVertex)
+      if (vtxESD)
         fdNdEtaAnalysisTrVtx->FillEvent(vtxMC[2], nAcceptedParticles);
     }
 
-    if (eventTriggered && eventVertex)
+    if (eventTriggered && vtxESD)
     {
       // from tracks is only done for triggered and vertex reconstructed events
 
@@ -443,7 +434,7 @@ void AlidNdEtaTask::Terminate(Option_t *)
     new TCanvas;
     fMult->Draw();
     fMultVtx->SetLineColor(2);
-    fMultVtx->DrawCopy("SAME");
+    fMultVtx->Draw("SAME");
   }
 
   if (fPartEta[0])
@@ -469,7 +460,7 @@ void AlidNdEtaTask::Terminate(Option_t *)
   if (fEvents)
   {
     new TCanvas("control3", "control3", 500, 500);
-    fEvents->DrawCopy();
+    fEvents->Draw();
   }
 
   TFile* fout = new TFile("analysis_esd_raw.root", "RECREATE");
@@ -537,7 +528,7 @@ void AlidNdEtaTask::Terminate(Option_t *)
     if (fPartPt)
     {
       new TCanvas("control2", "control2", 500, 500);
-      fPartPt->DrawCopy();
+      fPartPt->Draw();
     }
   }
 }
index 6489d9e..4fb6bef 100644 (file)
@@ -4,6 +4,7 @@
 #define AlidNdEtaTask_H
 
 #include "AliAnalysisTask.h"
+#include "AliPWG0Helper.h"
 #include <TString.h>
 
 class AliESDtrackCuts;
@@ -14,8 +15,6 @@ class AliESDEvent;
 
 class AlidNdEtaTask : public AliAnalysisTask {
   public:
-    enum AnalysisMethod { kSPD = 0, kTPC };
-
     AlidNdEtaTask(const char* opt = "");
     virtual ~AlidNdEtaTask();
 
@@ -25,7 +24,7 @@ class AlidNdEtaTask : public AliAnalysisTask {
     virtual void   Terminate(Option_t*);
 
     void SetTrackCuts(AliESDtrackCuts* cuts) { fEsdTrackCuts = cuts; }
-    void SetAnalysisMode(AnalysisMethod mode) { fAnalysisMode = mode; }
+    void SetAnalysisMode(AliPWG0Helper::AnalysisMode mode) { fAnalysisMode = mode; }
     void SetReadMC(Bool_t flag = kTRUE) { fReadMC = flag; }
 
  protected:
@@ -33,7 +32,7 @@ class AlidNdEtaTask : public AliAnalysisTask {
     TList* fOutput;                  //! list send on output slot 0
 
     TString fOption;      // option string
-    AnalysisMethod fAnalysisMode; // detector that is used for analysis
+    AliPWG0Helper::AnalysisMode fAnalysisMode; // detector that is used for analysis
 
     Bool_t  fReadMC;       // if true reads MC data (to build correlation maps)
 
diff --git a/PWG0/dNdEta/CreateCuts.C b/PWG0/dNdEta/CreateCuts.C
deleted file mode 100644 (file)
index 6a150f2..0000000
+++ /dev/null
@@ -1,24 +0,0 @@
-/* $Id$ */
-
-// this macro creates the track and event cuts used in this analysis
-
-AliESDtrackCuts* CreateTrackCuts(Bool_t hists = kTRUE)
-{
-  AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts("AliESDtrackCuts");
-
-  if (hists)
-    esdTrackCuts->DefineHistograms(1);
-
-  esdTrackCuts->SetMinNClustersTPC(50);
-  esdTrackCuts->SetMaxChi2PerClusterTPC(3.5);
-  esdTrackCuts->SetMaxCovDiagonalElements(2,2,0.5,0.5,2);
-  //esdTrackCuts->SetMaxCovDiagonalElements(2,2,0.5,0.5,1e99);
-  //Printf("WARNING: no cut on 1/pt");
-  esdTrackCuts->SetRequireTPCRefit(kTRUE);
-
-  esdTrackCuts->SetMinNsigmaToVertex(3);
-  esdTrackCuts->SetRequireSigmaToVertex(kTRUE);
-  esdTrackCuts->SetAcceptKingDaughters(kFALSE);
-
-  return esdTrackCuts;
-}
index f937ab5..b693bfb 100644 (file)
@@ -39,7 +39,7 @@ dNdEtaAnalysis::dNdEtaAnalysis() :
 }
 
 //____________________________________________________________________
-dNdEtaAnalysis::dNdEtaAnalysis(Char_t* name, Char_t* title, const char* analysis) :
+dNdEtaAnalysis::dNdEtaAnalysis(Char_t* name, Char_t* title, AliPWG0Helper::AnalysisMode analysisMode) :
   TNamed(name, title),
   fData(0),
   fPtDist(0)
@@ -49,7 +49,7 @@ dNdEtaAnalysis::dNdEtaAnalysis(Char_t* name, Char_t* title, const char* analysis
   // TODO this binning has to be the same than in AliCorrection, somehow passed?!
   Float_t binLimitsPt[] = {0.0, 0.05, 0.1, 0.125, 0.15, 0.175, 0.2, 0.225, 0.25, 0.275, 0.3, 0.325, 0.35, 0.375, 0.4, 0.425, 0.45, 0.475, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.5, 2.0, 5.0, 10.0, 100.0};
 
-  fData = new AliCorrection("Analysis", Form("%s Analysis", title), analysis);
+  fData = new AliCorrection("Analysis", Form("%s Analysis", title), analysisMode);
 
   // do not add this hists to the directory
   Bool_t oldStatus = TH1::AddDirectoryStatus();
index ad8e70f..20d0e3d 100644 (file)
 
 #include <TNamed.h>
 #include "AlidNdEtaCorrection.h"
+#include "AliPWG0Helper.h"
 
 class TH1F;
 class TCollection;
 
-class AlidNdEtaCorrection;
 class AliCorrection;
 
 class dNdEtaAnalysis : public TNamed
@@ -32,7 +32,7 @@ public:
   enum { kVertexBinning = 1+2 }; // the first is for the whole vertex range, the others divide the vertex range
 
   dNdEtaAnalysis();
-  dNdEtaAnalysis(Char_t* name, Char_t* title, const char* analysis = "tpc");
+  dNdEtaAnalysis(Char_t* name, Char_t* title, AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kTPC);
   virtual ~dNdEtaAnalysis();
 
   dNdEtaAnalysis(const dNdEtaAnalysis &c);
index 933308a..5c435d7 100644 (file)
@@ -1420,3 +1420,39 @@ void drawPlots()
   drawPlots(5);
   drawPlots(2);
 }
+
+void CompareCorrection2Measured(const char* dataInput = "analysis_esd_raw.root", const char* correctionMapFile = "correction_map.root", const char* correctionMapFolder = "dndeta_correction")
+{
+  loadlibs();
+
+  AlidNdEtaCorrection* dNdEtaCorrection = new AlidNdEtaCorrection(correctionMapFolder, correctionMapFolder);
+  TFile::Open(correctionMapFile);
+  dNdEtaCorrection->LoadHistograms();
+
+  TFile* file = TFile::Open(dataInput);
+
+  if (!file)
+  {
+    cout << "Error. File not found" << endl;
+    return;
+  }
+
+  dNdEtaAnalysis* fdNdEtaAnalysis = new dNdEtaAnalysis("dndeta", "dndeta");
+  fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
+
+  gROOT->cd();
+  
+  TH3* hist1 = (TH3*) dNdEtaCorrection->GetTrack2ParticleCorrection()->GetTrackCorrection()->GetMeasuredHistogram()->Clone("mc");
+  hist1->SetTitle("mc");
+
+  TH3* hist2 = (TH3*) fdNdEtaAnalysis->GetData()->GetTrackCorrection()->GetMeasuredHistogram()->Clone("esd");
+  hist2->SetTitle("esd");
+
+  AliPWG0Helper::CreateDividedProjections(hist1, hist2);
+
+  new TCanvas; gROOT->FindObject("mc_yx_div_esd_yx")->Draw("COLZ");
+  new TCanvas; gROOT->FindObject("mc_zx_div_esd_zx")->Draw("COLZ");
+  new TCanvas; gROOT->FindObject("mc_zy_div_esd_zy")->Draw("COLZ");
+
+}
+  
index 596e040..c47badc 100644 (file)
@@ -1010,6 +1010,8 @@ mergeCorrectionsWithDifferentCrosssections(Char_t* correctionFileName="correctio
       TString name;
       name.Form("dndeta_correction_syst_%s_%s", typeName[j], changes[i]);
       AlidNdEtaCorrection* current = new AlidNdEtaCorrection(name, name);
+      current->LoadHistograms("dndeta_correction");
+      current->Reset();
 
       name.Form("dndeta_correction_ND");
       AlidNdEtaCorrection* dNdEtaCorrectionND = new AlidNdEtaCorrection(name,name);
index fbdd39f..b5c1e86 100644 (file)
@@ -33,15 +33,6 @@ void run(Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, B
   // Create the analysis manager
   mgr = new AliAnalysisManager;
 
-  // selection of esd tracks
-  gROOT->ProcessLine(".L CreateCuts.C");
-  AliESDtrackCuts* esdTrackCuts = CreateTrackCuts();
-  if (!esdTrackCuts)
-  {
-    printf("ERROR: esdTrackCuts could not be created\n");
-    return;
-  }
-
   TString taskName("AlidNdEtaTask.cxx+");
   if (aDebug)
     taskName += "+g";
@@ -53,8 +44,23 @@ void run(Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, B
     gROOT->Macro(taskName);
 
   task = new AlidNdEtaTask(option);
-  task->SetTrackCuts(esdTrackCuts);
-  task->SetAnalysisMode(AlidNdEtaTask::kSPD);
+
+  AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kTPC;
+  task->SetAnalysisMode(analysisMode);
+
+  if (analysisMode != AliPWG0Helper::kSPD)
+  {
+    // selection of esd tracks
+    gROOT->ProcessLine(".L ../CreateStandardCuts.C");
+    AliESDtrackCuts* esdTrackCuts = CreateTrackCuts(analysisMode);
+    if (!esdTrackCuts)
+    {
+      printf("ERROR: esdTrackCuts could not be created\n");
+      return;
+    }
+
+    task->SetTrackCuts(esdTrackCuts);
+  }
 
   if (mc)
     task->SetReadMC();
@@ -120,7 +126,7 @@ void FinishAnalysisAll(const char* dataInput = "analysis_esd_raw.root", const ch
   dNdEtaAnalysis* fdNdEtaAnalysis = new dNdEtaAnalysis("dndeta", "dndeta");
   fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
   fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kINEL);
-  fdNdEtaAnalysis->DrawHistograms(kTRUE);
+  //fdNdEtaAnalysis->DrawHistograms(kTRUE);
   TFile* file2 = TFile::Open(dataOutput, "RECREATE");
   fdNdEtaAnalysis->SaveHistograms();
 
@@ -128,7 +134,7 @@ void FinishAnalysisAll(const char* dataInput = "analysis_esd_raw.root", const ch
   fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTr", "dndetaTr");
   fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
   fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kVertexReco);
-  fdNdEtaAnalysis->DrawHistograms(kTRUE);
+  //fdNdEtaAnalysis->DrawHistograms(kTRUE);
   file2->cd();
   fdNdEtaAnalysis->SaveHistograms();
 
@@ -136,7 +142,7 @@ void FinishAnalysisAll(const char* dataInput = "analysis_esd_raw.root", const ch
   fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTrVtx", "dndetaTrVtx");
   fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
   fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kTrack2Particle);
-  fdNdEtaAnalysis->DrawHistograms(kTRUE);
+  //fdNdEtaAnalysis->DrawHistograms(kTRUE);
   file2->cd();
   fdNdEtaAnalysis->SaveHistograms();
 
@@ -144,7 +150,7 @@ void FinishAnalysisAll(const char* dataInput = "analysis_esd_raw.root", const ch
   fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTracks", "dndetaTracks");
   fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
   fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone);
-  fdNdEtaAnalysis->DrawHistograms(kTRUE);
+  //fdNdEtaAnalysis->DrawHistograms(kTRUE);
   file2->cd();
   fdNdEtaAnalysis->SaveHistograms();
 }
index 8d6fe92..aafa043 100644 (file)
@@ -53,8 +53,23 @@ void runCorrection(Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug =
     gROOT->Macro(taskName);
 
   task = new AlidNdEtaCorrectionTask(option);
-  task->SetTrackCuts(esdTrackCuts);
-  task->SetAnalysisMode(AlidNdEtaCorrectionTask::kTPC);
+
+  AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kTPC;
+  task->SetAnalysisMode(analysisMode);
+
+  if (analysisMode != AliPWG0Helper::kSPD)
+  {
+    // selection of esd tracks
+    gROOT->ProcessLine(".L ../CreateStandardCuts.C");
+    AliESDtrackCuts* esdTrackCuts = CreateTrackCuts(analysisMode);
+    if (!esdTrackCuts)
+    {
+      printf("ERROR: esdTrackCuts could not be created\n");
+      return;
+    }
+
+    task->SetTrackCuts(esdTrackCuts);
+  }
 
   mgr->AddTask(task);
 
index 74ce696..9d2e308 100644 (file)
@@ -55,16 +55,16 @@ public:
   // track quality cut setters  
   void SetMinNClustersTPC(Int_t min=-1)          {fCutMinNClusterTPC=min;}
   void SetMinNClustersITS(Int_t min=-1)          {fCutMinNClusterITS=min;}
-  void SetMaxChi2PerClusterTPC(Float_t max=1e99) {fCutMaxChi2PerClusterTPC=max;}
-  void SetMaxChi2PerClusterITS(Float_t max=1e99) {fCutMaxChi2PerClusterITS=max;}
+  void SetMaxChi2PerClusterTPC(Float_t max=1e10) {fCutMaxChi2PerClusterTPC=max;}
+  void SetMaxChi2PerClusterITS(Float_t max=1e10) {fCutMaxChi2PerClusterITS=max;}
   void SetRequireTPCRefit(Bool_t b=kFALSE)       {fCutRequireTPCRefit=b;}
   void SetRequireITSRefit(Bool_t b=kFALSE)       {fCutRequireITSRefit=b;}
   void SetAcceptKingDaughters(Bool_t b=kFALSE)   {fCutAcceptKinkDaughters=b;}
-  void SetMaxCovDiagonalElements(Float_t c1=1e99, Float_t c2=1e99, Float_t c3=1e99, Float_t c4=1e99, Float_t c5=1e99) 
+  void SetMaxCovDiagonalElements(Float_t c1=1e10, Float_t c2=1e10, Float_t c3=1e10, Float_t c4=1e10, Float_t c5=1e10) 
     {fCutMaxC11=c1; fCutMaxC22=c2; fCutMaxC33=c3; fCutMaxC44=c4; fCutMaxC55=c5;}
 
   // track to vertex cut setters
-  void SetMinNsigmaToVertex(Float_t sigma=1e99)       {fCutNsigmaToVertex = sigma;}
+  void SetMinNsigmaToVertex(Float_t sigma=1e10)       {fCutNsigmaToVertex = sigma;}
   void SetRequireSigmaToVertex(Bool_t b=kTRUE )       {fCutSigmaToVertexRequired = b;}
 
   // getters
@@ -72,13 +72,13 @@ public:
   Bool_t GetRequireSigmaToVertex( )    { return fCutSigmaToVertexRequired;}
 
   // track kinmatic cut setters
-  void SetPRange(Float_t r1=0, Float_t r2=1e99)       {fPMin=r1;   fPMax=r2;}
-  void SetPtRange(Float_t r1=0, Float_t r2=1e99)      {fPtMin=r1;  fPtMax=r2;}
-  void SetPxRange(Float_t r1=-1e99, Float_t r2=1e99)  {fPxMin=r1;  fPxMax=r2;}
-  void SetPyRange(Float_t r1=-1e99, Float_t r2=1e99)  {fPyMin=r1;  fPyMax=r2;}
-  void SetPzRange(Float_t r1=-1e99, Float_t r2=1e99)  {fPzMin=r1;  fPzMax=r2;}
-  void SetEtaRange(Float_t r1=-1e99, Float_t r2=1e99) {fEtaMin=r1; fEtaMax=r2;}
-  void SetRapRange(Float_t r1=-1e99, Float_t r2=1e99) {fRapMin=r1; fRapMax=r2;}
+  void SetPRange(Float_t r1=0, Float_t r2=1e10)       {fPMin=r1;   fPMax=r2;}
+  void SetPtRange(Float_t r1=0, Float_t r2=1e10)      {fPtMin=r1;  fPtMax=r2;}
+  void SetPxRange(Float_t r1=-1e10, Float_t r2=1e10)  {fPxMin=r1;  fPxMax=r2;}
+  void SetPyRange(Float_t r1=-1e10, Float_t r2=1e10)  {fPyMin=r1;  fPyMax=r2;}
+  void SetPzRange(Float_t r1=-1e10, Float_t r2=1e10)  {fPzMin=r1;  fPzMax=r2;}
+  void SetEtaRange(Float_t r1=-1e10, Float_t r2=1e10) {fEtaMin=r1; fEtaMax=r2;}
+  void SetRapRange(Float_t r1=-1e10, Float_t r2=1e10) {fRapMin=r1; fRapMax=r2;}
 
   //######################################################
   void SetHistogramsOn(Bool_t b=kFALSE) {fHistogramsOn = b;}