replaced THXF to THX in many function prototypes
authorjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 31 Jul 2008 12:47:47 +0000 (12:47 +0000)
committerjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 31 Jul 2008 12:47:47 +0000 (12:47 +0000)
16 files changed:
PWG0/AliCorrection.cxx
PWG0/AliCorrectionMatrix2D.cxx
PWG0/AliCorrectionMatrix2D.h
PWG0/AliCorrectionMatrix3D.cxx
PWG0/AliCorrectionMatrix3D.h
PWG0/dNdEta/AlidNdEtaCorrection.cxx
PWG0/dNdEta/AlidNdEtaCorrectionSelector.cxx [deleted file]
PWG0/dNdEta/AlidNdEtaCorrectionSelector.h [deleted file]
PWG0/dNdEta/AlidNdEtaTask.cxx
PWG0/dNdEta/dNdEtaAnalysis.cxx
PWG0/dNdEta/drawPlots.C
PWG0/dNdEta/drawSystematics.C
PWG0/dNdEta/run.C
PWG0/multiplicity/AliMultiplicityTask.cxx
PWG0/multiplicity/AliMultiplicityTask.h
PWG0/multiplicity/plots.C

index 98db421..44198fa 100644 (file)
@@ -350,7 +350,7 @@ void AliCorrection::Multiply()
   {
     fEventCorr->Multiply();
     // now we manually copy the overflow bin of the y axis (multiplicity) over. This is important to get the event count correct
-    TH2F* hist = fEventCorr->GetMeasuredHistogram();
+    TH2* hist = fEventCorr->GetMeasuredHistogram();
     for (Int_t x = 1; x <= hist->GetNbinsX(); ++x)
       fEventCorr->GetGeneratedHistogram()->SetBinContent(x, hist->GetNbinsY() + 1, hist->GetBinContent(x, hist->GetNbinsY() + 1));
   }
index 4d9a0dc..891de0b 100644 (file)
@@ -101,20 +101,20 @@ AliCorrectionMatrix2D::~AliCorrectionMatrix2D()
   // histograms already deleted in base class
 }
 
-TH2F* AliCorrectionMatrix2D::GetGeneratedHistogram() const
+TH2* AliCorrectionMatrix2D::GetGeneratedHistogram() const
 {
   // return generated histogram casted to correct type
-  return dynamic_cast<TH2F*> (fhGene);
+  return dynamic_cast<TH2*> (fhGene);
 }
 
-TH2F* AliCorrectionMatrix2D::GetMeasuredHistogram() const
+TH2* AliCorrectionMatrix2D::GetMeasuredHistogram() const
 {
   // return measured histogram casted to correct type
-  return dynamic_cast<TH2F*> (fhMeas);
+  return dynamic_cast<TH2*> (fhMeas);
 }
 
 //____________________________________________________________________
-TH1F* AliCorrectionMatrix2D::Get1DCorrectionHistogram(Char_t* opt, Float_t min, Float_t max)
+TH1* AliCorrectionMatrix2D::Get1DCorrectionHistogram(Char_t* opt, Float_t min, Float_t max)
 {
   //
   // integrate the correction over one variable 
@@ -134,11 +134,11 @@ TH1F* AliCorrectionMatrix2D::Get1DCorrectionHistogram(Char_t* opt, Float_t min,
     else {
       Printf("Getting 1D map. Including y-bins %d to %d", binMin, binMax);
 
-      meas1D = ((TH2F*)fhMeas)->ProjectionX(Form("%s_pm", GetName()),binMin,binMax);
-      gene1D = ((TH2F*)fhGene)->ProjectionX(Form("%s_pg", GetName()),binMin,binMax);
+      meas1D = ((TH2F*)fhMeas)->ProjectionX(Form("%s_x_pm", GetName()),binMin,binMax);
+      gene1D = ((TH2F*)fhGene)->ProjectionX(Form("%s_x_pg", GetName()),binMin,binMax);
     }
   }
-  if (strcmp(opt,"y")==0) {
+  else if (strcmp(opt,"y")==0) {
     Int_t binMin = fhMeas->GetXaxis()->FindBin(min);
     Int_t binMax = fhMeas->GetXaxis()->FindBin(max);
 
@@ -147,12 +147,17 @@ TH1F* AliCorrectionMatrix2D::Get1DCorrectionHistogram(Char_t* opt, Float_t min,
       gene1D = ((TH2F*)fhGene)->ProjectionY();
     }
     else {
-      AliDebug(AliLog::kDebug+1, Form("Getting 1D map. Including x-bins %d to %d \n", binMin, binMax));
+      Printf("Getting 1D map. Including x-bins %d to %d \n", binMin, binMax);
 
-      meas1D = ((TH2F*)fhMeas)->ProjectionY(Form("%s_pm", GetName()), binMin, binMax);
-      gene1D = ((TH2F*)fhGene)->ProjectionY(Form("%s_pg", GetName()), binMin, binMax);
+      meas1D = ((TH2F*)fhMeas)->ProjectionY(Form("%s_y_pm", GetName()), binMin, binMax);
+      gene1D = ((TH2F*)fhGene)->ProjectionY(Form("%s_y_pg", GetName()), binMin, binMax);
     }
   }
+  else {
+    Printf("ERROR: Invalid option");
+    return 0;
+  }
+
   gene1D->Sumw2();
 
   gene1D->SetName(Form("corr_1D_%s",fName.Data()));
index 4726a89..8a30353 100644 (file)
@@ -31,13 +31,13 @@ public:
 
   AliCorrectionMatrix2D& operator= (const AliCorrectionMatrix2D& c);
 
-  TH2F* GetGeneratedHistogram() const;
-  TH2F* GetMeasuredHistogram() const;
+  TH2* GetGeneratedHistogram() const;
+  TH2* GetMeasuredHistogram() const;
 
-  TH2F* GetCorrectionHistogram() {return (TH2F*)fhCorr;}
+  TH2* GetCorrectionHistogram() {return (TH2*)fhCorr;}
 
-  TH1F* Get1DCorrection(Char_t* opt="x", Float_t min=0, Float_t max=0) {return Get1DCorrectionHistogram(opt,min,max);}
-  TH1F* Get1DCorrectionHistogram(Char_t* opt="x", Float_t min=0, Float_t max=0);
+  TH1* Get1DCorrection(Char_t* opt="x", Float_t min=0, Float_t max=0) {return Get1DCorrectionHistogram(opt,min,max);}
+  TH1* Get1DCorrectionHistogram(Char_t* opt="x", Float_t min=0, Float_t max=0);
 
   void Rebin(Int_t x = 1, Int_t y = 1);
 
index b953f3b..3e37f08 100644 (file)
@@ -100,7 +100,7 @@ AliCorrectionMatrix3D::AliCorrectionMatrix3D(const Char_t* name, const Char_t* t
   delete[] binLimitsY;
 }
 
-AliCorrectionMatrix3D::AliCorrectionMatrix3D(const Char_t* name, const Char_t* title, TH3F* hBinning)
+AliCorrectionMatrix3D::AliCorrectionMatrix3D(const Char_t* name, const Char_t* title, TH3* hBinning)
   : AliCorrectionMatrix(name, title)
 {
   // constructor with variable bin sizes (uses binning of hBinning)
@@ -162,21 +162,21 @@ AliCorrectionMatrix3D::~AliCorrectionMatrix3D()
 }
 
 //____________________________________________________________________
-TH3F* AliCorrectionMatrix3D::GetGeneratedHistogram()
+TH3* AliCorrectionMatrix3D::GetGeneratedHistogram()
 {
   // return generated histogram casted to correct type
   return dynamic_cast<TH3F*> (fhGene);
 }
 
 //____________________________________________________________________
-TH3F* AliCorrectionMatrix3D::GetMeasuredHistogram()
+TH3* AliCorrectionMatrix3D::GetMeasuredHistogram()
 {
   // return measured histogram casted to correct type
   return dynamic_cast<TH3F*> (fhMeas);
 }
 
 //____________________________________________________________________
-TH3F* AliCorrectionMatrix3D::GetCorrectionHistogram()
+TH3* AliCorrectionMatrix3D::GetCorrectionHistogram()
 {
   // return correction histogram casted to correct type
   return dynamic_cast<TH3F*> (fhCorr);
@@ -190,13 +190,13 @@ AliCorrectionMatrix2D* AliCorrectionMatrix3D::Get2DCorrection(Char_t* opt, Float
   TString option = opt;
 
   // unzoom
-  fhMeas->GetXaxis()->UnZoom();
-  fhMeas->GetYaxis()->UnZoom();
-  fhMeas->GetZaxis()->UnZoom();
+  fhMeas->GetXaxis()->SetRange(0, 0);
+  fhMeas->GetYaxis()->SetRange(0, 0);
+  fhMeas->GetZaxis()->SetRange(0, 0);
 
-  fhGene->GetXaxis()->UnZoom();
-  fhGene->GetYaxis()->UnZoom();
-  fhGene->GetZaxis()->UnZoom();
+  fhGene->GetXaxis()->SetRange(0, 0);
+  fhGene->GetYaxis()->SetRange(0, 0);
+  fhGene->GetZaxis()->SetRange(0, 0);
 
   if (aMin<aMax) {
     if (option.Contains("xy") || option.Contains("yx")) {
@@ -238,19 +238,19 @@ AliCorrectionMatrix2D* AliCorrectionMatrix3D::Get2DCorrection(Char_t* opt, Float
   corr2D->Divide();
 
   // unzoom
-  fhMeas->GetXaxis()->UnZoom();
-  fhMeas->GetYaxis()->UnZoom();
-  fhMeas->GetZaxis()->UnZoom();
+  fhMeas->GetXaxis()->SetRange(0, 0);
+  fhMeas->GetYaxis()->SetRange(0, 0);
+  fhMeas->GetZaxis()->SetRange(0, 0);
 
-  fhGene->GetXaxis()->UnZoom();
-  fhGene->GetYaxis()->UnZoom();
-  fhGene->GetZaxis()->UnZoom();
+  fhGene->GetXaxis()->SetRange(0, 0);
+  fhGene->GetYaxis()->SetRange(0, 0);
+  fhGene->GetZaxis()->SetRange(0, 0);
 
   return corr2D;
 }
 
 //____________________________________________________________________
-TH1F* AliCorrectionMatrix3D::Get1DCorrectionHistogram(Char_t* opt, Float_t aMin1, Float_t aMax1, Float_t aMin2, Float_t aMax2)
+TH1* AliCorrectionMatrix3D::Get1DCorrectionHistogram(Char_t* opt, Float_t aMin1, Float_t aMax1, Float_t aMin2, Float_t aMax2)
 {
   // returns a 1D projection of this correction
   AliDebug(AliLog::kWarning, Form("WARNING: test"));
@@ -268,7 +268,7 @@ TH1F* AliCorrectionMatrix3D::Get1DCorrectionHistogram(Char_t* opt, Float_t aMin1
     corr2D = Get2DCorrection("yz",aMin1,aMax1);
     return corr2D->Get1DCorrectionHistogram("x",aMin2,aMax2);
   }  
-  AliDebug(AliLog::kWarning, Form("WARNING: unknown projection option %s (should be x,y or z)", opt));  
+  AliDebug(AliLog::kWarning, Form("WARNING: unknown projection option %s (should be x,y or z)", opt));
   
   return 0;
 }
@@ -327,7 +327,7 @@ Int_t AliCorrectionMatrix3D::CheckEmptyBins(Float_t xmin, Float_t xmax, Float_t
   // counts the number of empty Bins in a given region
   //
 
-  TH3F* hist = GetGeneratedHistogram();
+  TH3* hist = GetGeneratedHistogram();
   if (!hist)
     return -1;
 
@@ -346,16 +346,16 @@ Int_t AliCorrectionMatrix3D::CheckEmptyBins(Float_t xmin, Float_t xmax, Float_t
 }
 
 //____________________________________________________________________
-TH1F* AliCorrectionMatrix3D::PlotBinErrors(Float_t xmin, Float_t xmax, Float_t ymin, Float_t ymax, Float_t zmin, Float_t zmax)
+TH1* AliCorrectionMatrix3D::PlotBinErrors(Float_t xmin, Float_t xmax, Float_t ymin, Float_t ymax, Float_t zmin, Float_t zmax)
 {
   //
   // makes a 1d plots of the relative bin errors
   //
 
-  TH3F* hist = GetCorrectionHistogram();
+  TH3* hist = GetCorrectionHistogram();
   if (!hist)
     return 0;
-    
+
   TH1F* target = new TH1F("relerrors", "relerrors", 100, 0, 10);
 
   for (Int_t x=hist->GetXaxis()->FindBin(xmin); x<=hist->GetXaxis()->FindBin(xmax); ++x)
index a9d090c..5101d4f 100644 (file)
@@ -12,9 +12,9 @@
 #include <AliCorrectionMatrix.h>
 #include <AliCorrectionMatrix2D.h>
 
-class TH3F;
-class TH2F;
-class TH1F;
+class TH3;
+class TH2;
+class TH1;
 
 
 class AliCorrectionMatrix3D : public AliCorrectionMatrix
@@ -32,7 +32,7 @@ public:
          Int_t nBinY, Float_t Ymin, Float_t Ymax,
          Int_t nBinZ, const Float_t* zbins);
 
-  AliCorrectionMatrix3D(const Char_t* name, const Char_t* title, TH3F* hBinning);
+  AliCorrectionMatrix3D(const Char_t* name, const Char_t* title, TH3* hBinning);
  
   virtual ~AliCorrectionMatrix3D();
 
@@ -42,13 +42,13 @@ public:
                   Int_t nBinY, const Float_t* binLimitsY,
                   Int_t nBinZ, const Float_t* binLimitsZ);
 
-  TH3F* GetGeneratedHistogram();
-  TH3F* GetMeasuredHistogram();
-  TH3F* GetCorrectionHistogram();
+  TH3* GetGeneratedHistogram();
+  TH3* GetMeasuredHistogram();
+  TH3* GetCorrectionHistogram();
 
   AliCorrectionMatrix2D* Get2DCorrection(Char_t* opt, Float_t aMin, Float_t aMax);
-  TH2F* Get2DCorrectionHistogram(Char_t* opt, Float_t aMin, Float_t aMax) {return Get2DCorrection(opt,aMin,aMax)->GetCorrectionHistogram();}
-  TH1F* Get1DCorrectionHistogram(Char_t* opt, Float_t aMins1=0, Float_t aMax1=0, Float_t aMins2=0, Float_t aMax2=0);
+  TH2* Get2DCorrectionHistogram(Char_t* opt, Float_t aMin, Float_t aMax) {return Get2DCorrection(opt,aMin,aMax)->GetCorrectionHistogram();}
+  TH1* Get1DCorrectionHistogram(Char_t* opt, Float_t aMins1=0, Float_t aMax1=0, Float_t aMins2=0, Float_t aMax2=0);
 
   void FillMeas(Float_t ax, Float_t ay, Float_t az);
   void FillGene(Float_t ax, Float_t ay, Float_t az);
@@ -60,7 +60,7 @@ public:
   virtual void SaveHistograms();
 
   Int_t CheckEmptyBins(Float_t xmin, Float_t xmax, Float_t ymin, Float_t ymax, Float_t zmin, Float_t zmax, Bool_t quiet = kFALSE);
-  TH1F* PlotBinErrors(Float_t xmin, Float_t xmax, Float_t ymin, Float_t ymax, Float_t zmin, Float_t zmax);
+  TH1* PlotBinErrors(Float_t xmin, Float_t xmax, Float_t ymin, Float_t ymax, Float_t zmin, Float_t zmax);
 
 
 protected:
index bafbfac..0ff81ba 100644 (file)
@@ -339,7 +339,7 @@ Float_t AlidNdEtaCorrection::GetMeasuredFraction(CorrectionType correctionType,
   if (!GetCorrection(correctionType))
     return -1;
 
-  const TH3F* generated = GetCorrection(correctionType)->GetTrackCorrection()->GetGeneratedHistogram();
+  const TH3* generated = GetCorrection(correctionType)->GetTrackCorrection()->GetGeneratedHistogram();
 
   // find eta borders, if eta is negative assume -0.8 ... 0.8
   Int_t etaBegin = 0;
@@ -401,7 +401,7 @@ TH1* AlidNdEtaCorrection::GetMeasuredEventFraction(CorrectionType correctionType
   if (!GetCorrection(correctionType))
     return 0;
 
-  const TH2F* generated = GetCorrection(correctionType)->GetEventCorrection()->GetGeneratedHistogram();
+  const TH2* generated = GetCorrection(correctionType)->GetEventCorrection()->GetGeneratedHistogram();
 
   TH1* allEvents = generated->ProjectionX(Form("%s_all", generated->GetName()), 1, generated->GetNbinsY());
   TH1* aboveEvents = generated->ProjectionX(Form("%s_above", generated->GetName()), generated->GetYaxis()->FindBin(multCut), generated->GetNbinsY());
diff --git a/PWG0/dNdEta/AlidNdEtaCorrectionSelector.cxx b/PWG0/dNdEta/AlidNdEtaCorrectionSelector.cxx
deleted file mode 100644 (file)
index 8c13cb0..0000000
+++ /dev/null
@@ -1,441 +0,0 @@
-/* $Id$ */
-
-#include "AlidNdEtaCorrectionSelector.h"
-
-#include <TStyle.h>
-#include <TSystem.h>
-#include <TCanvas.h>
-#include <TParticle.h>
-#include <TParticlePDG.h>
-#include <TH1F.h>
-
-#include <TChain.h>
-#include <TSelector.h>
-#include <TFile.h>
-
-#include <AliLog.h>
-#include <AliTracker.h>
-#include <AliESDVertex.h>
-#include <AliESD.h>
-#include <AliESDtrack.h>
-#include <AliRunLoader.h>
-#include <AliStack.h>
-
-#include <AliHeader.h>
-#include <AliGenEventHeader.h>
-#include <../STEER/AliGenPythiaEventHeader.h>
-#include <../STEER/AliGenCocktailEventHeader.h>
-
-#include "esdTrackCuts/AliESDtrackCuts.h"
-#include "dNdEta/AlidNdEtaCorrection.h"
-#include "AliPWG0Helper.h"
-
-#include "dNdEta/dNdEtaAnalysis.h"
-
-ClassImp(AlidNdEtaCorrectionSelector)
-
-AlidNdEtaCorrectionSelector::AlidNdEtaCorrectionSelector() :
-  AliSelectorRL(),
-  fEsdTrackCuts(0),
-  fdNdEtaCorrection(0),
-  fdNdEtaAnalysisMC(0),
-  fdNdEtaAnalysisESD(0),
-  fPIDParticles(0),
-  fPIDTracks(0),
-  fClustersITSPos(0),
-  fClustersTPCPos(0),
-  fClustersITSNeg(0),
-  fClustersTPCNeg(0),
-  fSignMode(0)
-{
-  //
-  // Constructor. Initialization of pointers
-  //
-}
-
-AlidNdEtaCorrectionSelector::~AlidNdEtaCorrectionSelector()
-{
-  //
-  // Destructor
-  //
-
-  // histograms are in the output list and deleted when the output
-  // list is deleted by the TSelector dtor
-}
-
-Bool_t AlidNdEtaCorrectionSelector::SignOK(TParticlePDG* particle)
-{
-  // returns if a particle with this sign should be counted
-  // this is determined by the value of fSignMode, which should have the same sign
-  // as the charge
-  // if fSignMode is 0 all particles are counted
-
-  if (fSignMode == 0)
-    return kTRUE;
-
-  if (!particle)
-  {
-    printf("WARNING: not counting a particle that does not have a pdg particle\n");
-    return kFALSE;
-  }
-
-  Double_t charge = particle->Charge();
-
-  if (fSignMode > 0)
-    if (charge < 0)
-      return kFALSE;
-
-  if (fSignMode < 0)
-    if (charge > 0)
-      return kFALSE;
-
-  return kTRUE;
-}
-
-void AlidNdEtaCorrectionSelector::ReadUserObjects(TTree* tree)
-{
-  // read the user objects, called from slavebegin and begin
-
-  if (!fEsdTrackCuts && fInput)
-    fEsdTrackCuts = dynamic_cast<AliESDtrackCuts*> (fInput->FindObject("AliESDtrackCuts"));
-
-  if (!fEsdTrackCuts && tree)
-    fEsdTrackCuts = dynamic_cast<AliESDtrackCuts*> (tree->GetUserInfo()->FindObject("AliESDtrackCuts"));
-
-  if (!fEsdTrackCuts)
-     AliDebug(AliLog::kError, "ERROR: Could not read EsdTrackCuts from input list.");
-}
-
-void AlidNdEtaCorrectionSelector::Begin(TTree * tree)
-{
-  // The Begin() function is called at the start of the query.
-  // When running with PROOF Begin() is only called on the client.
-  // The tree argument is deprecated (on PROOF 0 is passed).
-
-  AliSelectorRL::Begin(tree);
-
-  ReadUserObjects(tree);
-
-  TString option = GetOption();
-  AliInfo(Form("Called with option %s.", option.Data()));
-
-  if (option.Contains("only-positive"))
-  {
-    AliInfo("Processing only positive particles.");
-    fSignMode = 1;
-  }
-  else if (option.Contains("only-negative"))
-  {
-    AliInfo("Processing only negative particles.");
-    fSignMode = -1;
-  }
-}
-
-void AlidNdEtaCorrectionSelector::SlaveBegin(TTree * tree)
-{
-  // The SlaveBegin() function is called after the Begin() function.
-  // When running with PROOF SlaveBegin() is called on each slave server.
-  // The tree argument is deprecated (on PROOF 0 is passed).
-
-  AliSelectorRL::SlaveBegin(tree);
-
-  ReadUserObjects(tree);
-
-  fdNdEtaCorrection = new AlidNdEtaCorrection("dndeta_correction", "dndeta_correction");
-
-  fPIDParticles = new TH1F("pid_particles", "PID of generated primary particles", 10001, -5000.5, 5000.5);
-  fPIDTracks = new TH1F("pid_tracks", "MC PID of reconstructed tracks", 10001, -5000.5, 5000.5);
-
-  fClustersITSPos = new TH1F("clusters_its_pos", "clusters_its_pos", 7, -0.5, 6.5);
-  fClustersTPCPos = new TH1F("clusters_tpc_pos", "clusters_tpc_pos", 160, -0.5, 159.5);
-
-  fClustersITSNeg = new TH1F("clusters_its_neg", "clusters_its_neg", 7, -0.5, 6.5);
-  fClustersTPCNeg = new TH1F("clusters_tpc_neg", "clusters_tpc_neg", 160, -0.5, 159.5);
-
-  fdNdEtaAnalysisMC = new dNdEtaAnalysis("dndetaMC", "dndetaMC");
-  fdNdEtaAnalysisESD = new dNdEtaAnalysis("dndetaESD", "dndetaESD");
-}
-
-void AlidNdEtaCorrectionSelector::Init(TTree* tree)
-{
-  // read the user objects
-
-  AliSelectorRL::Init(tree);
-
-  // Enable only the needed branches
-  if (tree)
-  {
-    tree->SetBranchStatus("*", 0);
-    tree->SetBranchStatus("fTriggerMask", 1);
-    tree->SetBranchStatus("fSPDVertex*", 1);
-    tree->SetBranchStatus("fTracks.fLabel", 1);
-    tree->SetBranchStatus("fTracks.fITSncls", 1);
-    tree->SetBranchStatus("fTracks.fTPCncls", 1);
-
-    AliESDtrackCuts::EnableNeededBranches(tree);
-  }
-}
-
-Bool_t AlidNdEtaCorrectionSelector::Process(Long64_t entry)
-{
-  // The Process() function is called for each entry in the tree (or possibly
-  // keyed object in the case of PROOF) to be processed. The entry argument
-  // specifies which entry in the currently loaded tree is to be processed.
-  // It can be passed to either TTree::GetEntry() or TBranch::GetEntry()
-  // to read either all or the required parts of the data. When processing
-  // keyed objects with PROOF, the object is already loaded and is available
-  // via the fObject pointer.
-  //
-  // This function should contain the "body" of the analysis. It can contain
-  // simple or elaborate selection criteria, run algorithms on the data
-  // of the event and typically fill histograms.
-
-  // WARNING when a selector is used with a TChain, you must use
-  //  the pointer to the current TTree to call GetEntry(entry).
-  //  The entry is always the local entry number in the current tree.
-  //  Assuming that fTree is the pointer to the TChain being processed,
-  //  use fTree->GetTree()->GetEntry(entry).
-
-  AliDebug(AliLog::kDebug+1,"Processing event ...\n");
-
-  if (AliSelectorRL::Process(entry) == kFALSE)
-    return kFALSE;
-
-  // check prerequesites
-  if (!fESD)
-  {
-    AliDebug(AliLog::kError, "ESD branch not available");
-    return kFALSE;
-  }
-
-  AliHeader* header = GetHeader();
-  if (!header)
-  {
-    AliDebug(AliLog::kError, "Header not available");
-    return kFALSE;
-  }
-
-  AliStack* stack = GetStack();
-  if (!stack)
-  {
-    AliDebug(AliLog::kError, "Stack not available");
-    return kFALSE;
-  }
-
-  if (!fEsdTrackCuts)
-  {
-    AliDebug(AliLog::kError, "fESDTrackCuts not available");
-    return kFALSE;
-  }
-
-  Bool_t vertexReconstructed = AliPWG0Helper::IsVertexReconstructed(fESD);
-
-  Bool_t eventTriggered = AliPWG0Helper::IsEventTriggered(fESD);
-
-  // get the MC vertex
-  AliGenEventHeader* genHeader = header->GenEventHeader();
-
-  // primary vertex (from MC)
-  TArrayF vtxMC(3);
-  genHeader->PrimaryVertex(vtxMC);
-
-  // get process type
-  Int_t processType = AliPWG0Helper::GetPythiaEventProcessType(header);
-  AliDebug(AliLog::kDebug+1, Form("Found pythia procces type %d", processType));
-
-  if (processType<0)
-    AliDebug(AliLog::kError, Form("Unknown Pythia process type %d.", processType));
-
-  // loop over mc particles
-  Int_t nPrim  = stack->GetNprimary();
-
-  for (Int_t iMc = 0; iMc < nPrim; ++iMc)
-  {
-    AliDebug(AliLog::kDebug+1, Form("MC Loop: Processing particle %d.", iMc));
-
-    TParticle* particle = stack->Particle(iMc);
-
-    if (!particle)
-    {
-      AliDebug(AliLog::kError, Form("UNEXPECTED: particle with label %d not found in stack (mc loop).", iMc));
-      continue;
-    }
-
-    if (AliPWG0Helper::IsPrimaryCharged(particle, nPrim) == kFALSE)
-      continue;
-
-    if (SignOK(particle->GetPDG()) == kFALSE)
-      continue;
-
-    Float_t eta = particle->Eta();
-    Float_t pt = particle->Pt();
-
-    fdNdEtaCorrection->FillMCParticle(vtxMC[2], eta, pt, eventTriggered, vertexReconstructed, processType);
-
-    if (eventTriggered)
-    {
-      if (vertexReconstructed)
-      {
-        fdNdEtaAnalysisMC->FillTrack(vtxMC[2], eta, pt);
-      }
-    }
-  } // end of mc particle
-
-  // ########################################################
-  // loop over esd tracks
-  Int_t nTracks = fESD->GetNumberOfTracks();
-
-  // count the number of "good" tracks as parameter for vertex reconstruction efficiency
-  Int_t nGoodTracks = 0;
-  for (Int_t t=0; t<nTracks; t++)
-  {
-    AliDebug(AliLog::kDebug+1, Form("ESD Loop: Processing track %d.", t));
-
-    AliESDtrack* esdTrack = fESD->GetTrack(t);
-
-    // cut the esd track?
-    if (!fEsdTrackCuts->AcceptTrack(esdTrack))
-      continue;
-
-    nGoodTracks++;
-
-    // using the properties of the mc particle
-    Int_t label = TMath::Abs(esdTrack->GetLabel());
-    if (label == 0)
-    {
-      AliDebug(AliLog::kWarning, Form("WARNING: cannot find corresponding mc part for track %d.", t));
-      continue;
-    }
-
-    TParticle* particle = stack->Particle(label);
-    if (!particle)
-    {
-      AliDebug(AliLog::kError, Form("UNEXPECTED: particle with label %d not found in stack (track loop).", label));
-      continue;
-    }
-
-    if (SignOK(particle->GetPDG()) == kFALSE)
-        continue;
-
-    if (eventTriggered && vertexReconstructed)
-    {
-      fdNdEtaCorrection->FillTrackedParticle(vtxMC[2], particle->Eta(), particle->Pt());
-      fdNdEtaAnalysisESD->FillTrack(vtxMC[2], particle->Eta(), particle->Pt());
-      if (particle->Pt() > 0.1 && particle->Pt() < 0.2)
-      {
-        fPIDTracks->Fill(particle->GetPdgCode());
-        if (particle->GetPDG()->Charge() > 0)
-        {
-          fClustersITSPos->Fill(esdTrack->GetITSclusters(0));
-          fClustersTPCPos->Fill(esdTrack->GetTPCclusters(0));
-        }
-        else
-        {
-          fClustersITSNeg->Fill(esdTrack->GetITSclusters(0));
-          fClustersTPCNeg->Fill(esdTrack->GetTPCclusters(0));
-        }
-      }
-    }
-  } // end of track loop
-
-  if (eventTriggered && vertexReconstructed)
-    fdNdEtaAnalysisMC->FillEvent(vtxMC[2], nGoodTracks);
-
-  // stuff regarding the vertex reco correction and trigger bias correction
-  fdNdEtaCorrection->FillEvent(vtxMC[2], nGoodTracks, eventTriggered, vertexReconstructed, processType);
-  if (eventTriggered) {
-    if (vertexReconstructed)
-    {
-      fdNdEtaAnalysisESD->FillEvent(vtxMC[2], nGoodTracks);
-    }
-  }
-
-  return kTRUE;
-}
-
-void AlidNdEtaCorrectionSelector::SlaveTerminate()
-{
-  // The SlaveTerminate() function is called after all entries or objects
-  // have been processed. When running with PROOF SlaveTerminate() is called
-  // on each slave server.
-
-  AliSelectorRL::SlaveTerminate();
-
-  // Add the histograms to the output on each slave server
-  if (!fOutput)
-  {
-    AliDebug(AliLog::kError, "ERROR: Output list not initialized");
-    return;
-  }
-
-  fOutput->Add(fdNdEtaCorrection);
-  fOutput->Add(fdNdEtaAnalysisMC);
-  fOutput->Add(fdNdEtaAnalysisESD);
-}
-
-void AlidNdEtaCorrectionSelector::Terminate()
-{
-  // The Terminate() function is the last function to be called during
-  // a query. It always runs on the client, it can be used to present
-  // the results graphically or save the results to file.
-
-  AliSelectorRL::Terminate();
-
-  fdNdEtaCorrection = dynamic_cast<AlidNdEtaCorrection*> (fOutput->FindObject("dndeta_correction"));
-  fdNdEtaAnalysisMC = dynamic_cast<dNdEtaAnalysis*> (fOutput->FindObject("dndetaMC"));
-  fdNdEtaAnalysisESD = dynamic_cast<dNdEtaAnalysis*> (fOutput->FindObject("dndetaESD"));
-  if (!fdNdEtaCorrection || !fdNdEtaAnalysisMC || !fdNdEtaAnalysisESD)
-  {
-    AliDebug(AliLog::kError, "Could not read object from output list");
-    return;
-  }
-
-  fdNdEtaCorrection->Finish();
-
-  TFile* fout = new TFile(Form("correction_map%s.root", GetOption()), "RECREATE");
-
-  if (fEsdTrackCuts)
-    fEsdTrackCuts->SaveHistograms("esd_track_cuts");
-  fdNdEtaCorrection->SaveHistograms();
-  fdNdEtaAnalysisMC->SaveHistograms();
-  fdNdEtaAnalysisESD->SaveHistograms();
-
-  fout->Write();
-  fout->Close();
-
-  fdNdEtaCorrection->DrawHistograms();
-
-  if (fPIDParticles && fPIDTracks)
-  {
-    new TCanvas("pidcanvas", "pidcanvas", 500, 500);
-
-    fPIDParticles->Draw();
-    fPIDTracks->SetLineColor(2);
-    fPIDTracks->Draw("SAME");
-
-    TDatabasePDG* pdgDB = new TDatabasePDG;
-
-    for (Int_t i=0; i <= fPIDParticles->GetNbinsX()+1; ++i)
-      if (fPIDParticles->GetBinContent(i) > 0)
-        printf("PDG = %d (%s): generated: %d, reconstructed: %d, ratio: %f\n", (Int_t) fPIDParticles->GetBinCenter(i), pdgDB->GetParticle((Int_t) fPIDParticles->GetBinCenter(i))->GetName(), (Int_t) fPIDParticles->GetBinContent(i), (Int_t) fPIDTracks->GetBinContent(i), ((fPIDTracks->GetBinContent(i) > 0) ? fPIDParticles->GetBinContent(i) / fPIDTracks->GetBinContent(i) : -1));
-
-    delete pdgDB;
-    pdgDB = 0;
-  }
-
-  if (fClustersITSPos && fClustersITSNeg && fClustersTPCPos && fClustersTPCNeg)
-  {
-    TCanvas* canvas = new TCanvas("clusters", "clusters", 1000, 500);
-    canvas->Divide(2, 1);
-
-    canvas->cd(1);
-    fClustersITSPos->Draw();
-    fClustersITSNeg->SetLineColor(kRed);
-    fClustersITSNeg->Draw("SAME");
-
-    canvas->cd(2);
-    fClustersTPCPos->Draw();
-    fClustersTPCNeg->SetLineColor(kRed);
-    fClustersTPCNeg->Draw("SAME");
-  }
-}
diff --git a/PWG0/dNdEta/AlidNdEtaCorrectionSelector.h b/PWG0/dNdEta/AlidNdEtaCorrectionSelector.h
deleted file mode 100644 (file)
index da6b494..0000000
+++ /dev/null
@@ -1,55 +0,0 @@
-/* $Id$ */
-
-#ifndef ALIDNDETACORRECTIONSELECTOR_H
-#define ALIDNDETACORRECTIONSELECTOR_H
-
-#include "AliSelectorRL.h"
-
-class AliESDtrackCuts;
-class AlidNdEtaCorrection;
-class TH1F;
-class TParticlePDG;
-class dNdEtaAnalysis;
-
-class AlidNdEtaCorrectionSelector : public AliSelectorRL {
-  public:
-    AlidNdEtaCorrectionSelector();
-    virtual ~AlidNdEtaCorrectionSelector();
-
-    void ReadUserObjects(TTree* tree);
-    virtual void    Begin(TTree *tree);
-    virtual void    SlaveBegin(TTree *tree);
-    virtual void    Init(TTree *tree);
-    virtual Bool_t  Process(Long64_t entry);
-    virtual void    SlaveTerminate();
-    virtual void    Terminate();
-
- protected:
-    Bool_t SignOK(TParticlePDG* particle);
-
-    AliESDtrackCuts*  fEsdTrackCuts;          // Object containing the parameters of the esd track cuts
-
-    AlidNdEtaCorrection* fdNdEtaCorrection;      // contains the intermediate histograms (on each slave)
-
-    dNdEtaAnalysis* fdNdEtaAnalysisMC; // analysis from MC (only triggered, vertex events)
-    dNdEtaAnalysis* fdNdEtaAnalysisESD; // analysis from ESD (not yet corrected!)
-
-    TH1F* fPIDParticles; // pid of primary particles
-    TH1F* fPIDTracks; // pid of reconstructed tracks
-
-    TH1F* fClustersITSPos; //
-    TH1F* fClustersTPCPos; //
-
-    TH1F* fClustersITSNeg; //
-    TH1F* fClustersTPCNeg; //
-
-    Int_t fSignMode;  // if 0 process all particles, if +-1 process only particles with that sign
-
- private:
-    AlidNdEtaCorrectionSelector(const AlidNdEtaCorrectionSelector&);
-    AlidNdEtaCorrectionSelector& operator=(const AlidNdEtaCorrectionSelector&);
-
-  ClassDef(AlidNdEtaCorrectionSelector, 0);
-};
-
-#endif
index 66f0d09..c5f46ba 100644 (file)
@@ -135,6 +135,15 @@ void AlidNdEtaTask::CreateOutputObjects()
 
   Printf("AlidNdEtaTask::CreateOutputObjects");
 
+  if (fOnlyPrimaries)
+    Printf("WARNING: Processing only primaries (MC information used). This is for systematical checks only.");
+
+  if (fUseMCKine)
+    Printf("WARNING: Using MC kine information. This is for systematical checks only.");
+
+  if (fUseMCVertex)
+    Printf("WARNING: Replacing vertex by MC vertex. This is for systematical checks only.");
+
   fOutput = new TList;
   fOutput->SetOwner();
 
@@ -271,10 +280,7 @@ void AlidNdEtaTask::Exec(Option_t*)
       genHeader->PrimaryVertex(vtxMC);
 
       if (fUseMCVertex)
-      {
-        Printf("WARNING: Replacing vertex by MC vertex. This is for systematical checks only.");
         vtx[2] = vtxMC[2];
-      }
 
       stack = mcEvent->Stack();
       if (!stack)
@@ -303,9 +309,6 @@ void AlidNdEtaTask::Exec(Option_t*)
       etaArr = new Float_t[mult->GetNumberOfTracklets()];
       ptArr = new Float_t[mult->GetNumberOfTracklets()];
 
-      if (fOnlyPrimaries)
-        Printf("Processing only primaries (MC information used). This is for systematical checks only.");
-
       // get multiplicity from ITS tracklets
       for (Int_t i=0; i<mult->GetNumberOfTracklets(); ++i)
       {
@@ -359,12 +362,6 @@ void AlidNdEtaTask::Exec(Option_t*)
       etaArr = new Float_t[nGoodTracks];
       ptArr = new Float_t[nGoodTracks];
 
-      if (fOnlyPrimaries)
-        Printf("WARNING: Processing only primaries (MC information used). This is for systematical checks only.");
-
-      if (fUseMCKine)
-        Printf("WARNING: Using MC kine information. This is for systematical checks only.");
-
       // loop over esd tracks
       for (Int_t i=0; i<nGoodTracks; i++)
       {
index 34e5c69..f1537d3 100644 (file)
@@ -209,8 +209,8 @@ void dNdEtaAnalysis::Finish(AlidNdEtaCorrection* correction, Float_t ptCut, Alid
 
   if (correction && correctionType != AlidNdEtaCorrection::kNone)
   {
-    TH3F* trackCorr = fData->GetTrackCorrection()->GetCorrectionHistogram();
-    TH2F* eventCorr = fData->GetEventCorrection()->GetCorrectionHistogram();
+    TH3* trackCorr = fData->GetTrackCorrection()->GetCorrectionHistogram();
+    TH2* eventCorr = fData->GetEventCorrection()->GetCorrectionHistogram();
 
     if (correctionType >= AlidNdEtaCorrection::kTrack2Particle)
       trackCorr->Multiply(correction->GetTrack2ParticleCorrection()->GetTrackCorrection()->GetCorrectionHistogram());
@@ -307,10 +307,10 @@ void dNdEtaAnalysis::Finish(AlidNdEtaCorrection* correction, Float_t ptCut, Alid
 
   fData->PrintInfo(ptCut);
 
-  TH3F* dataHist = fData->GetTrackCorrection()->GetGeneratedHistogram();
+  TH3* dataHist = fData->GetTrackCorrection()->GetGeneratedHistogram();
 
   // integrate multiplicity axis out (include under/overflow bins!!!)
-  TH2F* tmp = fData->GetEventCorrection()->GetGeneratedHistogram();
+  TH2* tmp = fData->GetEventCorrection()->GetGeneratedHistogram();
 
   TH1D* vertexHist = (TH1D*) tmp->ProjectionX("_px", 0, tmp->GetNbinsY() + 1, "e");
 
index 8eb5f73..1590528 100644 (file)
@@ -674,51 +674,6 @@ void ptSpectrum()
   canvas->SaveAs("ptSpectrum.eps");
 }
 
-void ptCutoff()
-{
-  gSystem->Load("libPWG0base");
-
-  TFile::Open("correction_map.root");
-  AlidNdEtaCorrection* dNdEtaCorrection = new AlidNdEtaCorrection("dndeta_correction", "dndeta_correction");
-  dNdEtaCorrection->LoadHistograms();
-
-  dNdEtaCorrection->GetMeasuredFraction(AlidNdEtaCorrection::kINEL, 0.3, -100, kTRUE);
-
-  TH1* hist = dynamic_cast<TH1*> (gROOT->FindObject("generated_pt")->Clone("ptcutoff"));
-
-  hist->GetXaxis()->SetRangeUser(0, 0.9999);
-  hist->SetMinimum(0);
-
-  hist->SetTitle("Generated Particles");
-  Prepare1DPlot(hist);
-
-  TCanvas* canvas = new TCanvas("ptCutoff", "ptCutoff", 700, 500);
-  hist->DrawCopy();
-
-  TLine* line = new TLine(0.3, 0 - hist->GetMaximum() * 0, 0.3, hist->GetMaximum() * 1.1);
-  line->SetLineWidth(3);
-  line->SetLineColor(kRed);
-  line->Draw();
-
-  canvas->SaveAs("ptCutoff.gif");
-  canvas->SaveAs("ptCutoff.eps");
-
-  TH1F* factor = new TH1F("factor", ";#eta;correction factor", 20, -1, 1.000001);
-  factor->SetLineWidth(2);
-  for (Float_t eta = -0.95; eta<1; eta += 0.1)
-    factor->Fill(eta, 1.0 / dNdEtaCorrection->GetMeasuredFraction(AlidNdEtaCorrection::kINEL, 0.3, eta, kFALSE));
-
-  TCanvas* canvas = new TCanvas("ptCutoff_factor", "ptCutoff_factor", 700, 500);
-  InitPad();
-
-  Prepare1DPlot(factor);
-  factor->GetYaxis()->SetRangeUser(1, 2);
-  factor->GetYaxis()->SetTitleOffset(1);
-  factor->Draw();
-
-  canvas->SaveAs("ptCutoff_factor.eps");
-}
-
 void TriggerBiasVtxRecon(const char* fileName = "correction_map.root", const char* folder = "dndeta_correction")
 {
   gSystem->Load("libPWG0base");
@@ -999,22 +954,22 @@ void Correction1DCreatePlots(const char* fileName = "correction_map.root", const
   meas->GetZaxis()->SetRangeUser(0.3, upperPtLimit);
   gene->GetYaxis()->SetRangeUser(-0.8, 0.8);
   meas->GetYaxis()->SetRangeUser(-0.8, 0.8);
-  AliPWG0Helper::CreateDividedProjections(gene, meas, "x", kTRUE);
+  AliPWG0Helper::CreateDividedProjections(gene, meas, "x", kFALSE);
   gene->GetYaxis()->SetRange(0, 0);
   meas->GetYaxis()->SetRange(0, 0);
 
-  gene->GetXaxis()->SetRangeUser(-10, 10);
-  meas->GetXaxis()->SetRangeUser(-10, 10);
-  AliPWG0Helper::CreateDividedProjections(gene, meas, "y", kTRUE);
+  gene->GetXaxis()->SetRangeUser(-9.9, 9.9);
+  meas->GetXaxis()->SetRangeUser(-9.9, 9.9);
+  AliPWG0Helper::CreateDividedProjections(gene, meas, "y", kFALSE);
   gene->GetZaxis()->SetRange(0, 0);
   meas->GetZaxis()->SetRange(0, 0);
 
   gene->GetYaxis()->SetRangeUser(-0.8, 0.8);
   meas->GetYaxis()->SetRangeUser(-0.8, 0.8);
-  AliPWG0Helper::CreateDividedProjections(gene, meas, "z", kTRUE);
+  AliPWG0Helper::CreateDividedProjections(gene, meas, "z", kFALSE);
 }
 
-void Correction1D(Int_t correctionType = 0, const char* fileName = "correction_map.root", const char* folder = "dndeta_correction", Float_t upperPtLimit = 9.9)
+TCanvas* Correction1D(Int_t correctionType = 0, const char* fileName = "correction_map.root", const char* folder = "dndeta_correction", Float_t upperPtLimit = 9.9)
 {
   gSystem->Load("libPWG0base");
 
@@ -1035,28 +990,44 @@ void Correction1D(Int_t correctionType = 0, const char* fileName = "correction_m
   corrX->GetYaxis()->SetTitle("correction factor");
   corrY->GetYaxis()->SetTitle("correction factor");
   corrZ->GetYaxis()->SetTitle("correction factor");
+  corrX->GetYaxis()->SetTitleOffset(1.7);
+  corrY->GetYaxis()->SetTitleOffset(1.7);
+  corrZ->GetYaxis()->SetTitleOffset(1.7);
+  corrX->GetYaxis()->SetRangeUser(0.8, 1.5);
+  corrY->GetYaxis()->SetRangeUser(0.8, 1.5);
+  corrZ->GetYaxis()->SetRangeUser(0.8, 1.5);
 
-  corrZ->GetXaxis()->SetRangeUser(0, upperPtLimit);
+  corrZ->GetXaxis()->SetRangeUser(0.11, upperPtLimit);
 
   TString canvasName;
-  canvasName.Form("Correction1D_%s", folder);
+  canvasName.Form(Form("Correction1D_%d_%s_%f", correctionType, fileName, upperPtLimit));
   TCanvas* canvas = new TCanvas(canvasName, canvasName, 1200, 400);
   canvas->Divide(3, 1);
 
+  TLatex* Tl = new TLatex;
+  Tl->SetTextSize(0.04);
+  Tl->SetBit(TLatex::kTextNDC);
+
   canvas->cd(1);
   InitPad();
   corrX->DrawCopy();
+  Tl->DrawLatex(0.6, 0.8, "0.3 < p_{T} < 10");
+  Tl->DrawLatex(0.6, 0.75, "|#eta| < 0.8");
 
   canvas->cd(2);
   InitPad();
   corrY->Draw();
+  Tl->DrawLatex(0.6, 0.8, "0.3 < p_{T} < 10");
+  Tl->DrawLatex(0.6, 0.75, "|vtx-z| < 10");
 
   canvas->cd(3);
   InitPad();
+  gPad->SetLogx();
   corrZ->Draw();
+  Tl->DrawLatex(0.6, 0.8, "|vtx-z| < 10");
+  Tl->DrawLatex(0.6, 0.75, "|#eta| < 0.8");
 
-  canvas->SaveAs(Form("Correction1D_%d_%s_%f.gif", correctionType, fileName, upperPtLimit));
-  canvas->SaveAs(Form("Correction1D_%d_%s_%f.eps", correctionType, fileName, upperPtLimit));
+  return canvas;
 }
 
 void Track2Particle1D(const char* fileName = "correction_map.root", const char* folder = "dndeta_correction", Float_t upperPtLimit = 9.9)
@@ -1858,28 +1829,35 @@ void GetAverageCorrectionFactor(Float_t etaRange = 1.5, Float_t vertexRange = 9.
   mcH->Fit("pol0", "", "", -etaRange, etaRange);
 }
 
-void TrackCuts_Comparison(char* histName, Bool_t after = kFALSE, const char* fileName = "correction_map.root")
+void TrackCuts_Comparison(char* histName, Int_t plotWhich = 0, const char* fileName = "correction_map.root")
 {
   // for the nsigmaplot it is needed to run with all cuts except the nsigmatovertex
   //    --> manually disable it in the run.C
+  //
+  // plotWhich: 0 = only before
+  //            1 = both
+  //            2 = only after
 
   file = TFile::Open(fileName);
 
   Int_t count = 0;
   Int_t colors[] = { 1, 2, 3, 4, 5, 6 };
 
-  TLegend* legend = new TLegend(0.4, 0.6, 1, 1);
+  TLegend* legend = new TLegend(0.5, 0.7, 1, 1);
   TLegend* legend2 = new TLegend(0.4, 0.6, 1, 1);
-  TLegend* legend3 = new TLegend(0.7, 0.5, 1, 0.7);
+  TLegend* legend3 = new TLegend(0.6, 0.5, 1, 0.7);
 
-  TCanvas* c1 = new TCanvas("c1", "c1", 800, 600);
+  TCanvas* c1 = new TCanvas("c1", "c1", 800, 1200);
+  c1->Divide(1, 2);
   //TCanvas* c2 = new TCanvas("c2", "c2", 800, 600);
-  TCanvas* c3 = new TCanvas("c3", "c3", 800, 600);
+  //TCanvas* c3 = new TCanvas("c3", "c3", 800, 600);
 
   const char* folders2[] = { "before_cuts", "after_cuts" };
-  for (Int_t j = 0; j < ((after) ? 2 : 1); j++)
+  Bool_t first = kTRUE;
+  for (Int_t j = ((plotWhich < 2) ? 0 : 1); j < ((plotWhich > 0) ? 2 : 1); j++)
   {
     const char* folders1[] = { "esd_track_cuts", "esd_track_cuts_primaries", "esd_track_cuts_secondaries" };
+    const char* names[] =    { "all", "primaries", "secondaries" };
     TH1* base = 0;
     TH1* prim = 0;
     TH1* sec = 0;
@@ -1888,9 +1866,9 @@ void TrackCuts_Comparison(char* histName, Bool_t after = kFALSE, const char* fil
       TString folder;
       folder.Form("%s/%s/%s", folders1[i], folders2[j], histName);
       TH1* hist = (TH1*) file->Get(folder);
-      legend->AddEntry(hist, folder);
+      legend->AddEntry(hist, Form("%s %s", names[i], folders2[j]));
 
-      c1->cd();
+      c1->cd(1);
       hist->SetLineColor(colors[count]);
       hist->DrawCopy((count == 0) ? "" : "SAME");
 
@@ -1910,7 +1888,8 @@ void TrackCuts_Comparison(char* histName, Bool_t after = kFALSE, const char* fil
     for (Int_t bin = 1; bin <= prim->GetNbinsX(); bin++)
     {
       eff->SetBinContent(bin, prim->Integral(1, bin) / prim->Integral(1, prim->GetNbinsX() + 1));
-      purity->SetBinContent(bin, sec->Integral(1, bin) / (prim->Integral(1, bin) + sec->Integral(1, bin)));
+      if (prim->Integral(1, bin) + sec->Integral(1, bin) > 0)
+        purity->SetBinContent(bin, sec->Integral(1, bin) / (prim->Integral(1, bin) + sec->Integral(1, bin)));
     }
 
     eff->GetYaxis()->SetRangeUser(0, 1);
@@ -1921,15 +1900,15 @@ void TrackCuts_Comparison(char* histName, Bool_t after = kFALSE, const char* fil
     legend3->AddEntry(eff, Form("%s: efficiency", folders2[j]));
     legend3->AddEntry(purity, Form("%s: contamination", folders2[j]));
 
-    c3->cd();
-    eff->DrawCopy((j == 0) ? "" : "SAME");
+    c1->cd(2);
+    eff->DrawCopy((first) ? "" : "SAME");
+    first = kFALSE;
     purity->DrawCopy("SAME");
   }
 
-  c1->cd();
-  c1->SetLogy();
-  c1->SetGridx();
-  c1->SetGridy();
+  c1->cd(1)->SetLogy();
+  c1->cd(1)->SetGridx();
+  c1->cd(1)->SetGridy();
   legend->Draw();
 
   //c2->cd();
@@ -1937,10 +1916,11 @@ void TrackCuts_Comparison(char* histName, Bool_t after = kFALSE, const char* fil
  // c2->SetGridy();
   //legend2->Draw();
 
-  c3->cd();
-  c3->SetGridx();
-  c3->SetGridy();
+  c1->cd(2)->SetGridx();
+  c1->cd(2)->SetGridy();
   legend3->Draw();
+
+  c1->SaveAs(Form("%s.png", histName));
 }
 
 void TrackCuts_DCA()
index 9854f6f..0d55f9a 100644 (file)
@@ -269,60 +269,6 @@ TH1** DrawRatios(const char* fileName = "systematics.root")
   return ptDists;
 }
 
-void DrawpiKpAndCombinedZOnly(Float_t upperPtLimit=0.99)
-{
-  gROOT->ProcessLine(".L drawPlots.C");
-  gSystem->Load("libPWG0base");
-
-  const char* fileNames[] = { "systematics.root", "systematics.root", "systematics.root", "correction_map.root" };
-  const char* folderNames[] = { "correction_0", "correction_1", "correction_2", "dndeta_correction" };
-  const char* legendNames[] = { "#pi", "K", "p", "standard" };
-  Int_t folderCount = 3;
-
-  /*const char* fileNames[] = { "systematics.root", "systematics.root", "systematics.root", "systematics.root", "correction_map.root" };
-  const char* folderNames[] = { "correction_0", "correction_1", "correction_2", "correction_3", "dndeta_correction" };
-  const char* legendNames[] = { "#pi", "K", "p", "others", "standard" };
-  Int_t folderCount = 5;*/
-
-  TString canvasName;
-  canvasName.Form("Track2Particle1DComposition");
-  TCanvas* canvas = new TCanvas(canvasName, canvasName, 700, 500);
-  canvas->SetGridx();
-  canvas->SetGridy();
-  canvas->SetBottomMargin(0.12);
-  //InitPad();
-
-  TLegend* legend = new TLegend(0.8, 0.7, 0.95, 0.95);
-  legend->SetFillColor(0);
-
-  Int_t mycolors[] = {1, 2, 4};
-
-  for (Int_t i=0; i<folderCount; ++i)
-  {
-    Track2Particle1DCreatePlots(fileNames[i], folderNames[i], upperPtLimit);
-
-    TH1* corrZ = dynamic_cast<TH1*> (gROOT->FindObject(Form("gene_%s_nTrackToNPart_z_div_meas_%s_nTrackToNPart_z", folderNames[i], folderNames[i])));
-
-    Prepare1DPlot(corrZ);
-
-    corrZ->SetTitle("");
-    corrZ->GetXaxis()->SetRangeUser(0, upperPtLimit);
-    corrZ->GetYaxis()->SetRangeUser(0.51, 6);
-    corrZ->SetMarkerColor(mycolors[i]);
-    corrZ->SetLineColor(mycolors[i]);
-    corrZ->SetMarkerStyle(markers[i+1]);
-    corrZ->GetYaxis()->SetTitle("correction factor");
-
-    corrZ->DrawCopy(((i>0) ? "SAMEP" : "P"));
-
-    legend->AddEntry(corrZ, legendNames[i]);
-  }
-
-  legend->Draw();
-
-  canvas->SaveAs("ptcutoff_species.eps");
-}
-
 void DrawCompareToReal()
 {
   gROOT->ProcessLine(".L drawPlots.C");
index 412d2bb..5e5ca33 100644 (file)
@@ -87,7 +87,7 @@ void run(Int_t runWhat, const Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool
     gROOT->Macro(compileTaskName);
 
   AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kSPD;
-  AliPWG0Helper::Trigger      trigger = AliPWG0Helper::kMB1;
+  AliPWG0Helper::Trigger      trigger      = AliPWG0Helper::kMB1;
 
   AliPWG0Helper::PrintConf(analysisMode, trigger);
 
index cf6e93d..061b051 100644 (file)
@@ -264,7 +264,7 @@ void AliMultiplicityTask::Exec(Option_t*)
     }
 
     // get multiplicity from ESD tracks
-    TObjArray* list = fEsdTrackCuts->GetAcceptedTracks(fESD);
+    TObjArray* list = fEsdTrackCuts->GetAcceptedTracks(fESD, (fAnalysisMode == AliPWG0Helper::kTPC));
     Int_t nGoodTracks = list->GetEntries();
 
     labelArr = new Int_t[nGoodTracks];
index 73d3293..fa4ef14 100644 (file)
@@ -44,7 +44,7 @@ class AliMultiplicityTask : public AliAnalysisTask {
     AliESDtrackCuts* fEsdTrackCuts;           // Object containing the parameters of the esd track cuts
 
     Bool_t fSystSkipParticles;     //! if true skips particles (systematic study)
-    AliCorrection* fParticleCorrection[4]; //! correction from measured to generated particles for trigger, vertex sample in |eta| < 2;
+    AliCorrection* fParticleCorrection[4]; //! correction from measured to generated particles for different particles for trigger, vertex sample in |eta| < 2; switch on with particle-efficiency
                                            // for each of the species: pi, k, p, other; for systematic study of pt cut off
     Int_t fSelectProcessType;        //! 0 = all (default), 1 = ND, 2 = SD, 3 = DD (for systematic study)
     TNtuple *fParticleSpecies;       //! per event: vtx_mc, (pi, k, p, rest (in |eta| < 2)) X (true, recon) + (nolabel,
index 47a542b..1894423 100644 (file)
@@ -41,6 +41,12 @@ const char* correctionFileTPC = "multiplicityMC_TPC_1.4M.root";
 const char* measuredFileTPC   = "multiplicityMC_TPC_0.6M.root";
 Int_t etaRangeTPC = 1;
 
+void loadlibs()
+{
+  gSystem->Load("libANALYSIS");
+  gSystem->Load("libPWG0base");
+}
+
 void SetTPC()
 {
   correctionFile = correctionFileTPC;
@@ -1212,20 +1218,21 @@ void SystematicMisalignmentTPC()
 
 void EfficiencySpecies()
 {
-  gSystem->Load("libPWG0base");
+  loadlibs();
 
   Int_t marker[] = {24, 25, 26};
   Int_t color[] = {1, 2, 4};
 
   // SPD TPC
-  const char* fileName[] = { "multiplicityMC_400k_syst.root", "multiplicityMC_TPC_4kfiles_syst.root" };
+  //const char* fileName[] = { "multiplicityMC_400k_syst.root", "multiplicityMC_TPC_4kfiles_syst.root" };
+  const char* fileName[] = { "spd/multiplicity.root", "tpc/multiplicity.root" };
   Float_t etaRange[] = {0.49, 0.9};
   const char* titles[] = { "SPD Tracklets", "TPC Tracks" };
 
   TCanvas* canvas = new TCanvas("EfficiencySpecies", "EfficiencySpecies", 1000, 500);
   canvas->Divide(2, 1);
 
-  for (Int_t loop=0; loop<1; ++loop)
+  for (Int_t loop=0; loop<2; ++loop)
   {
     Printf("%s", fileName[loop]);
 
@@ -1319,6 +1326,7 @@ void EfficiencySpecies()
       effPt->GetXaxis()->SetRangeUser(0.06, 1);
       effPt->GetYaxis()->SetRangeUser(0, 1);
 
+      effPt->GetXaxis()->SetTitleOffset(1.1);
       effPt->GetYaxis()->SetTitleOffset(1.2);
 
       effPt->SetStats(kFALSE);