adding class AliCorrection that comprises a correction on the event-level and on...
authorjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 1 Dec 2006 15:24:03 +0000 (15:24 +0000)
committerjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 1 Dec 2006 15:24:03 +0000 (15:24 +0000)
do not attach histograms to the directory while creating them

12 files changed:
PWG0/AliCorrection.cxx [new file with mode: 0644]
PWG0/AliCorrection.h [new file with mode: 0644]
PWG0/AliCorrectionMatrix.cxx
PWG0/AliCorrectionMatrix.h
PWG0/AliCorrectionMatrix2D.cxx
PWG0/AliCorrectionMatrix2D.h
PWG0/AliCorrectionMatrix3D.cxx
PWG0/AliPWG0Helper.cxx
PWG0/AliPWG0Helper.h
PWG0/CreateESDChain.C
PWG0/PWG0baseLinkDef.h
PWG0/libPWG0base.pkg

diff --git a/PWG0/AliCorrection.cxx b/PWG0/AliCorrection.cxx
new file mode 100644 (file)
index 0000000..d19eca3
--- /dev/null
@@ -0,0 +1,274 @@
+/* $Id$ */
+
+// ------------------------------------------------------
+//
+// Class to handle corrections.
+//
+// ------------------------------------------------------
+//
+
+#include <TFile.h>
+#include <TCanvas.h>
+#include <TH2F.h>
+
+#include <AliLog.h>
+#include "AliCorrectionMatrix2D.h"
+#include "AliCorrectionMatrix3D.h"
+
+#include "AliCorrection.h"
+
+//____________________________________________________________________
+ClassImp(AliCorrection)
+
+//____________________________________________________________________
+AliCorrection::AliCorrection() : TNamed(),
+  fEventCorr(0),
+  fTrackCorr(0)
+{
+  // default constructor
+}
+
+//____________________________________________________________________
+AliCorrection::AliCorrection(const Char_t* name, const Char_t* title) : TNamed(name, title),
+  fEventCorr(0),
+  fTrackCorr(0)
+{
+  // constructor initializing tnamed
+
+  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};
+  Float_t binLimitsN[]   = {-0.5, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10.5, 12.5, 14.5, 16.5, 18.5, 20.5, 25.5, 30.5, 40.5, 50.5, 100.5, 300.5};
+  //Float_t binLimitsVtx[] = {-20,-15,-10,-6,-3,0,3,6,10,15,20};
+  Float_t binLimitsVtx[] = {-20,-19,-18,-17,-16,-15,-14,-13,-12,-11,-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
+
+  fEventCorr = new AliCorrectionMatrix2D("EventCorrection", Form("%s EventCorrection", title), 40, binLimitsVtx, 22, binLimitsN);
+  fTrackCorr = new AliCorrectionMatrix3D("TrackCorrection", Form("%s TrackCorrection", title), 40, -20, 20, 20, -2, 2, 28, binLimitsPt);
+
+  fEventCorr->SetAxisTitles("vtx z [cm]", "Ntracks");
+  fTrackCorr->SetAxisTitles("vtx z [cm]", "#eta", "p_{T} [GeV/c]");
+}
+
+//____________________________________________________________________
+AliCorrection::AliCorrection(const AliCorrection& c) : TNamed(c),
+  fEventCorr(0),
+  fTrackCorr(0)
+{
+  // copy constructor
+  ((AliCorrection &)c).Copy(*this);
+}
+
+//____________________________________________________________________
+AliCorrection::~AliCorrection()
+{
+  //
+  // destructor
+  //
+
+  if (fEventCorr)
+  {
+    delete fEventCorr;
+    fEventCorr = 0;
+  }
+
+  if (fTrackCorr)
+  {
+    delete fTrackCorr;
+    fTrackCorr = 0;
+  }
+}
+
+//____________________________________________________________________
+AliCorrection &AliCorrection::operator=(const AliCorrection &c)
+{
+  // assigment operator
+
+  if (this != &c)
+    ((AliCorrection &) c).Copy(*this);
+
+  return *this;
+}
+
+//____________________________________________________________________
+void AliCorrection::Copy(TObject& c) const
+{
+  // copy function
+
+  AliCorrection& target = (AliCorrection &) c;
+
+  if (fEventCorr)
+    target.fEventCorr = dynamic_cast<AliCorrectionMatrix2D*> (fEventCorr->Clone());
+
+  if (fTrackCorr)
+    target.fTrackCorr = dynamic_cast<AliCorrectionMatrix3D*> (fTrackCorr->Clone());
+}
+
+//____________________________________________________________________
+Long64_t AliCorrection::Merge(TCollection* list)
+{
+  // Merge a list of AliCorrection objects with this (needed for
+  // PROOF). 
+  // Returns the number of merged objects (including this).
+
+  if (!list)
+    return 0;
+  
+  if (list->IsEmpty())
+    return 1;
+
+  TIterator* iter = list->MakeIterator();
+  TObject* obj;
+
+  // collections of measured and generated histograms
+  TList* collectionEvent = new TList;
+  TList* collectionTrack = new TList;
+  
+  Int_t count = 0;
+  while ((obj = iter->Next())) {
+    
+    AliCorrection* entry = dynamic_cast<AliCorrection*> (obj);
+    if (entry == 0) 
+      continue;
+
+    collectionEvent->Add(entry->fEventCorr);
+    collectionTrack->Add(entry->fTrackCorr);
+
+    count++;
+  }
+  fEventCorr->Merge(collectionEvent);
+  fTrackCorr->Merge(collectionTrack);
+
+  delete collectionEvent;
+  delete collectionTrack;
+
+  return count+1;
+}
+
+//____________________________________________________________________
+void AliCorrection::Divide()
+{
+  //
+  // divide the histograms to get the correction
+  //
+  
+  if (!fEventCorr || !fTrackCorr)
+    return;
+    
+  fEventCorr->Divide();
+  fTrackCorr->Divide();
+
+  Int_t emptyBins = fTrackCorr->CheckEmptyBins(-9.99, 9.99, -0.79, 0.79, 0.3, 9.9);
+  printf("INFO: In the central region the track correction of %s has %d empty bins\n", GetName(), emptyBins);
+}
+
+//____________________________________________________________________
+Bool_t AliCorrection::LoadHistograms(const Char_t* dir)
+{
+  //
+  // loads the histograms from a file
+  // if dir is empty a directory with the name of this object is taken (like in SaveHistogram)
+  //
+
+  if (!fEventCorr || !fTrackCorr)
+    return kFALSE;
+
+  if (!dir)
+    dir = GetName();
+
+  if (!gDirectory->cd(dir))
+    return kFALSE;
+
+  Bool_t success = fEventCorr->LoadHistograms();
+  success &= fTrackCorr->LoadHistograms();
+
+  gDirectory->cd("..");
+
+  return success;
+}
+
+//____________________________________________________________________
+void AliCorrection::SaveHistograms()
+{
+  //
+  // saves the histograms in a directory with the name of this object (GetName)
+  //
+  
+  gDirectory->mkdir(GetName());
+  gDirectory->cd(GetName());
+
+  if (fEventCorr)
+    fEventCorr->SaveHistograms();
+
+  if (fTrackCorr)
+    fTrackCorr->SaveHistograms();
+    
+  gDirectory->cd("..");
+}
+
+//____________________________________________________________________
+void AliCorrection::ReduceInformation()
+{
+  // this function deletes the measured and generated histograms to reduce the amount of data
+  // in memory
+
+  if (!fEventCorr || !fTrackCorr)
+    return;
+
+  fEventCorr->ReduceInformation();
+  fTrackCorr->ReduceInformation();
+}
+
+//____________________________________________________________________
+void AliCorrection::Reset(Option_t* option)
+{
+  // resets the histograms
+
+  if (fEventCorr)
+    fEventCorr->Reset(option);
+
+  if (fTrackCorr)
+    fTrackCorr->Reset(option);
+}
+
+//____________________________________________________________________
+void AliCorrection::DrawHistograms(const Char_t* name)
+{
+  // draws the corrections
+
+  if (!name)
+    name = GetName();
+
+  if (fEventCorr)
+    fEventCorr->DrawHistograms(Form("%s event", name));
+
+  if (fTrackCorr)
+    fTrackCorr->DrawHistograms(Form("%s track", name));
+}
+
+//____________________________________________________________________
+void AliCorrection::SetCorrectionToUnity()
+{
+  // set the corrections to unity
+
+  if (fEventCorr)
+    fEventCorr->SetCorrectionToUnity();
+
+  if (fTrackCorr)
+    fTrackCorr->SetCorrectionToUnity();
+}
+
+//____________________________________________________________________
+void AliCorrection::Multiply()
+{
+  // call Multiply
+
+  if (fEventCorr)
+  {
+    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();
+    for (Int_t x = 1; x <= hist->GetNbinsX(); ++x)
+      fEventCorr->GetGeneratedHistogram()->SetBinContent(x, hist->GetNbinsY() + 1, hist->GetBinContent(x, hist->GetNbinsY() + 1));
+  }
+
+  if (fTrackCorr)
+    fTrackCorr->Multiply();
+}
diff --git a/PWG0/AliCorrection.h b/PWG0/AliCorrection.h
new file mode 100644 (file)
index 0000000..620b409
--- /dev/null
@@ -0,0 +1,60 @@
+#ifndef ALICORRECTION_H
+#define ALICORRECTION_H
+
+/* $Id$ */
+
+// ------------------------------------------------------
+//
+// This class is used to store the correction for one effect. 
+//
+// Most effects have to be correction on track and event level, this class combines
+// two correction matrices. One of the type AliCorrectionMatrix2D and one of
+// the type AliCorrectionMatrix3D
+//
+// ------------------------------------------------------
+
+#include <TNamed.h>
+
+class AliCorrectionMatrix2D;
+class AliCorrectionMatrix3D;
+
+class AliCorrection : public TNamed
+{
+public:
+  AliCorrection();
+  AliCorrection(const Char_t* name, const Char_t* title);
+  AliCorrection(const AliCorrection& c);
+
+  virtual ~AliCorrection();
+  AliCorrection& operator=(const AliCorrection& corr);
+  virtual void Copy(TObject& c) const;
+
+  virtual Long64_t Merge(TCollection* list);
+
+  AliCorrectionMatrix2D* GetEventCorrection() { return fEventCorr; }
+  AliCorrectionMatrix3D* GetTrackCorrection() { return fTrackCorr; }
+
+  void SetEventCorrection(AliCorrectionMatrix2D* corr) { fEventCorr = corr; }
+  void SetTrackCorrection(AliCorrectionMatrix3D* corr) { fTrackCorr = corr; }
+
+  void Divide();
+  void Multiply();
+  void SetCorrectionToUnity();
+
+  virtual Bool_t LoadHistograms(const Char_t* dir = 0);
+  virtual void SaveHistograms();
+  virtual void DrawHistograms(const Char_t* name = 0);
+
+  virtual void ReduceInformation();
+
+  virtual void Reset(Option_t* option = "");
+
+protected:
+  AliCorrectionMatrix2D* fEventCorr; // correction on event level
+  AliCorrectionMatrix3D* fTrackCorr; // correction on track level
+
+  ClassDef(AliCorrection,1)
+};
+
+#endif
+
index 5264dd3..c54a532 100644 (file)
@@ -157,10 +157,10 @@ Long64_t AliCorrectionMatrix::Merge(TCollection* list)
 void AliCorrectionMatrix::Divide()
 {
   //
-  // divide the histograms to get the correction
-  // 
+  // divides generated by measured to get the correction
+  //
 
-  if (!fhMeas || !fhGene)
+  if (!fhMeas || !fhGene || !fhCorr)
     return;
 
   fhCorr->Divide(fhGene, fhMeas, 1, 1, "B");
@@ -173,40 +173,74 @@ void AliCorrectionMatrix::Divide()
           ++emptyBins;
 
   if (emptyBins > 0)
-    printf("INFO: In %s we have %d empty bins (of %d) in the correction map\n", GetName(), emptyBins, fhCorr->GetNbinsX() * fhCorr->GetNbinsY() * fhCorr->GetNbinsZ());
+    printf("INFO: In %s we have %d empty bins (of %d) in the correction map\n", GetTitle(), emptyBins, fhCorr->GetNbinsX() * fhCorr->GetNbinsY() * fhCorr->GetNbinsZ());
 }
 
 //____________________________________________________________________
-Bool_t AliCorrectionMatrix::LoadHistograms(const Char_t* fileName, const Char_t* dir)
+void AliCorrectionMatrix::Multiply()
+{
+  //
+  // multiplies measured with correction to get the generated
+  //
+
+  if (!fhMeas || !fhGene || !fhCorr)
+    return;
+
+  fhGene->Multiply(fhMeas, fhCorr, 1, 1, "B");
+}
+
+//____________________________________________________________________
+Bool_t AliCorrectionMatrix::LoadHistograms(const Char_t* dir)
 {
   //
   // loads the histograms from a file
+  // if dir is empty a directory with the name of this object is taken (like in SaveHistogram)
   //
 
-  TFile* fin = TFile::Open(fileName);
+  if (!dir)
+    dir = GetName();
 
-  if(!fin) {
-    //Info("LoadHistograms",Form(" %s file does not exist",fileName));
+  if (!gDirectory->cd(dir))
     return kFALSE;
+
+  if (fhGene)
+  {
+    delete fhGene;
+    fhGene=0;
   }
-  
-  if(fhGene)  {delete fhGene;  fhGene=0;}
-  if(fhCorr)  {delete fhCorr;  fhCorr=0;}
-  if(fhMeas)  {delete fhMeas;  fhMeas=0;}
-  
-  fhMeas  = dynamic_cast<TH1*> (fin->Get(Form("%s/meas_%s", dir,GetName())));
-  if(!fhMeas)  Info("LoadHistograms","No meas. (%s) hist available",Form("%s/meas_%s", dir,GetName()));
 
-  fhGene  = dynamic_cast<TH1*> (fin->Get(Form("%s/gene_%s",dir, GetName())));
-  if(!fhGene)  Info("LoadHistograms","No gene. (%s) hist available",Form("%s/gene_%s",dir, GetName()));
+  if (fhCorr)
+  {
+    delete fhCorr;
+    fhCorr=0;
+  }
 
-  fhCorr  = dynamic_cast<TH1*> (fin->Get(Form("%s/corr_%s",dir, GetName())));
-  if(!fhCorr) {
-    Info("LoadHistograms","No corr.(%s) hist available",Form("%s/corr_%s",dir, GetName()));
-    return kFALSE;
+  if (fhMeas)
+  {
+    delete fhMeas;
+    fhMeas=0;
   }
-      
-  return kTRUE;
+
+  fhMeas  = dynamic_cast<TH1*> (gDirectory->Get("measured"));
+  if (!fhMeas)
+    Info("LoadHistograms", "No measured hist available");
+
+  fhGene  = dynamic_cast<TH1*> (gDirectory->Get("generated"));
+  if (!fhGene)
+    Info("LoadHistograms", "No generated hist available");
+
+  fhCorr  = dynamic_cast<TH1*> (gDirectory->Get("correction"));
+
+  Bool_t success = kTRUE;
+  if (!fhCorr)
+  {
+    Info("LoadHistograms", "No correction hist available");
+    success = kFALSE;
+  }
+
+  gDirectory->cd("..");
+
+  return success;
 }
 
 //____________________________________________________________________
@@ -216,6 +250,9 @@ void AliCorrectionMatrix::SaveHistograms()
   // saves the histograms
   //
 
+  gDirectory->mkdir(GetName());
+  gDirectory->cd(GetName());
+
   if (fhMeas)
     fhMeas ->Write();
 
@@ -224,34 +261,40 @@ void AliCorrectionMatrix::SaveHistograms()
 
   if (fhCorr)
     fhCorr->Write();
+
+  gDirectory->cd("..");
 }
 
 //____________________________________________________________________
-void AliCorrectionMatrix::DrawHistograms()
+void AliCorrectionMatrix::DrawHistograms(const Char_t* canvasName)
 {
   //
-  // draws all the four histograms on one TCanvas
+  // draws all histograms on one TCanvas
+  // if canvasName is 0 the name of this object is taken
   //
 
-  TCanvas* canvas = new TCanvas(Form("correction_%s",fName.Data()), 
-                               Form("correction_%s",fName.Data()), 800, 800);
-  canvas->Divide(2, 2);
+  if (!canvasName)
+    canvasName = Form("%s_canvas", GetName());
+
+  TCanvas* canvas = new TCanvas(canvasName, GetTitle(), 1200, 400);
+  canvas->Divide(3, 1);
 
   canvas->cd(1);
   if (fhMeas)
     fhMeas->Draw("COLZ");
-  
+
   canvas->cd(2);
   if (fhGene)
+  {
+    // work around ROOT bug #22011
+    if (fhGene->GetEntries() == 0)
+      fhGene->SetEntries(1);
     fhGene->Draw("COLZ");
+  }
 
   canvas->cd(3);
   if (fhCorr)
     fhCorr->Draw("COLZ");
-
-  canvas->cd(4);
-
-  // add: draw here the stat. errors of the correction histogram
 }
 
 //____________________________________________________________________
@@ -287,3 +330,17 @@ void AliCorrectionMatrix::Reset(Option_t* option)
   if (fhCorr)
     fhCorr->Reset(option);
 }
+
+//____________________________________________________________________
+void AliCorrectionMatrix::SetCorrectionToUnity()
+{
+  // sets the correction matrix to unity
+
+  if (!fhCorr)
+    return;
+
+  for (Int_t x=1; x<=fhCorr->GetNbinsX(); ++x)
+    for (Int_t y=1; y<=fhCorr->GetNbinsY(); ++y)
+      for (Int_t z=1; z<=fhCorr->GetNbinsZ(); ++z)
+        fhCorr->SetBinContent(x, y, z, 1);
+}
index d4c490a..de28fb8 100644 (file)
@@ -33,18 +33,22 @@ public:
 
   TH1* GetGeneratedHistogram() { return fhGene; }
   TH1* GetMeasuredHistogram()  { return fhMeas; }
+  TH1* GetCorrectionHistogram() { return fhCorr; }
 
   void SetGeneratedHistogram(TH1* agene) { fhGene = agene; }
   void SetMeasuredHistogram(TH1* ameas)  { fhMeas = ameas; }
+  void SetCorrectionHistogram(TH1* acorr) { fhCorr = acorr; }
 
   void Divide();
+  void Multiply();
+  void SetCorrectionToUnity();
 
   void SetAxisTitles(const Char_t* titleX="", const Char_t* titleY="", const Char_t* titleZ="");
 
-  virtual Bool_t LoadHistograms(const Char_t* fileName, const Char_t* dir = ".");
+  virtual Bool_t LoadHistograms(const Char_t* dir = 0);
   virtual void SaveHistograms();
 
-  virtual void DrawHistograms();
+  virtual void DrawHistograms(const Char_t* canvasName = 0);
 
   virtual void ReduceInformation();
 
index 30f3ec3..cdb5307 100644 (file)
@@ -52,9 +52,15 @@ AliCorrectionMatrix2D::AliCorrectionMatrix2D(const Char_t* name, const Char_t* t
   // constructor
   //
 
-  fhMeas  = new TH2F(Form("meas_%s",name), Form("meas_%s",title),  nBinX, Xmin, Xmax, nBinY, Ymin, Ymax);
-  fhGene  = new TH2F(Form("gene_%s",name), Form("gene_%s",title),  nBinX, Xmin, Xmax, nBinY, Ymin, Ymax);
-  fhCorr  = new TH2F(Form("corr_%s",name), Form("corr_%s",title),  nBinX, Xmin, Xmax, nBinY, Ymin, Ymax);
+  // do not add this hists to the directory
+  Bool_t oldStatus = TH1::AddDirectoryStatus();
+  TH1::AddDirectory(kFALSE);
+
+  fhMeas  = new TH2F("measured",   Form("%s measured",title),   nBinX, Xmin, Xmax, nBinY, Ymin, Ymax);
+  fhGene  = new TH2F("generated",  Form("%s generated",title),  nBinX, Xmin, Xmax, nBinY, Ymin, Ymax);
+  fhCorr  = new TH2F("correction", Form("%s correction",title), nBinX, Xmin, Xmax, nBinY, Ymin, Ymax);
+
+  TH1::AddDirectory(oldStatus);
 
   fhMeas->Sumw2();
   fhGene->Sumw2();
@@ -70,11 +76,17 @@ AliCorrectionMatrix2D::AliCorrectionMatrix2D(const Char_t* name, const Char_t* t
   // constructor
   //
 
-  fhMeas  = new TH2F(Form("meas_%s",name), Form("meas_%s",title),  nBinX, X, nBinY, Y);
-  fhGene  = new TH2F(Form("gene_%s",name), Form("gene_%s",title),  nBinX, X, nBinY, Y);
-  fhCorr  = new TH2F(Form("corr_%s",name), Form("corr_%s",title),  nBinX, X, nBinY, Y);
+  // do not add this hists to the directory
+  Bool_t oldStatus = TH1::AddDirectoryStatus();
+  TH1::AddDirectory(kFALSE);
 
-  fhMeas->Sumw2();
+       fhMeas  = new TH2F("measured",   Form("%s measured",title),   nBinX, X, nBinY, Y);
+  fhGene  = new TH2F("generated",  Form("%s generated",title),  nBinX, X, nBinY, Y);
+  fhCorr  = new TH2F("correction", Form("%s correction",title), nBinX, X, nBinY, Y);
+
+  TH1::AddDirectory(oldStatus);
+
+       fhMeas->Sumw2();
   fhGene->Sumw2();
   fhCorr->Sumw2();
 }
index 05cdcd8..5fb445d 100644 (file)
@@ -33,7 +33,7 @@ public:
   TH2F* GetGeneratedHistogram() const;
   TH2F* GetMeasuredHistogram() const;
 
-  TH2F* GetCorrectionHistrogram() {return (TH2F*)fhCorr;}
+  TH2F* GetCorrectionHistogram() {return (TH2F*)fhCorr;}
   TH1F* Get1DCorrection(Char_t* opt="x", Float_t min=0, Float_t max=0);
 
   void FillMeas(Float_t ax, Float_t ay);
index a714603..a34f1a2 100644 (file)
@@ -55,9 +55,15 @@ AliCorrectionMatrix3D::AliCorrectionMatrix3D(const Char_t* name, const Char_t* t
   // constructor
   //
 
-  fhMeas  = new TH3F(Form("meas_%s",name), Form("meas_%s",title),  nBinX, Xmin, Xmax, nBinY, Ymin, Ymax, nBinZ, Zmin, Zmax);
-  fhGene  = new TH3F(Form("gene_%s",name), Form("gene_%s",title),  nBinX, Xmin, Xmax, nBinY, Ymin, Ymax, nBinZ, Zmin, Zmax);
-  fhCorr  = new TH3F(Form("corr_%s",name), Form("corr_%s",title),  nBinX, Xmin, Xmax, nBinY, Ymin, Ymax, nBinZ, Zmin, Zmax);
+  // do not add this hists to the directory
+  Bool_t oldStatus = TH1::AddDirectoryStatus();
+  TH1::AddDirectory(kFALSE);
+
+  fhMeas  = new TH3F("measured",   Form("%s measured",title),   nBinX, Xmin, Xmax, nBinY, Ymin, Ymax, nBinZ, Zmin, Zmax);
+  fhGene  = new TH3F("generated",  Form("%s generated",title),  nBinX, Xmin, Xmax, nBinY, Ymin, Ymax, nBinZ, Zmin, Zmax);
+  fhCorr  = new TH3F("correction", Form("%s correction",title), nBinX, Xmin, Xmax, nBinY, Ymin, Ymax, nBinZ, Zmin, Zmax);
+
+  TH1::AddDirectory(oldStatus);
 
   fhMeas->Sumw2();
   fhGene->Sumw2();
@@ -80,9 +86,15 @@ AliCorrectionMatrix3D::AliCorrectionMatrix3D(const Char_t* name, const Char_t* t
   for (Int_t i=0; i<=nBinY; ++i)
     binLimitsY[i] = Ymin + (Ymax - Ymin) / nBinY * i;
 
-  fhMeas  = new TH3F(Form("meas_%s",name), Form("meas_%s",title), nBinX, binLimitsX, nBinY, binLimitsY, nBinZ, zbins);
-  fhGene  = new TH3F(Form("gene_%s",name), Form("gene_%s",title), nBinX, binLimitsX, nBinY, binLimitsY, nBinZ, zbins);
-  fhCorr  = new TH3F(Form("corr_%s",name), Form("corr_%s",title), nBinX, binLimitsX, nBinY, binLimitsY, nBinZ, zbins);
+  // do not add this hists to the directory
+  Bool_t oldStatus = TH1::AddDirectoryStatus();
+  TH1::AddDirectory(kFALSE);
+
+  fhMeas  = new TH3F("measured",   Form("%s measured",title),   nBinX, binLimitsX, nBinY, binLimitsY, nBinZ, zbins);
+  fhGene  = new TH3F("generated",  Form("%s generated",title),  nBinX, binLimitsX, nBinY, binLimitsY, nBinZ, zbins);
+  fhCorr  = new TH3F("correction", Form("%s correction",title), nBinX, binLimitsX, nBinY, binLimitsY, nBinZ, zbins);
+
+  TH1::AddDirectory(oldStatus);
 
   delete[] binLimitsX;
   delete[] binLimitsY;
@@ -161,7 +173,13 @@ void AliCorrectionMatrix3D::SaveHistograms()
   AliCorrectionMatrix::SaveHistograms();
 
   if (GetGeneratedHistogram() && GetMeasuredHistogram())
-    AliPWG0Helper::CreateDividedProjections(GetGeneratedHistogram(), GetMeasuredHistogram());
+  {
+    gDirectory->cd(GetName());
+    
+    AliPWG0Helper::CreateDividedProjections(GetGeneratedHistogram(), GetMeasuredHistogram(), 0, kFALSE, kTRUE);
+    
+    gDirectory->cd("..");
+  }
 }
 
 //____________________________________________________________________
index b258d24..13e0102 100644 (file)
@@ -114,7 +114,7 @@ Bool_t AliPWG0Helper::IsPrimaryCharged(TParticle* aParticle, Int_t aTotalPrimari
 }
 
 //____________________________________________________________________
-void AliPWG0Helper::CreateProjections(TH3* hist)
+void AliPWG0Helper::CreateProjections(TH3* hist, Bool_t save)
 {
   // create projections of 3d hists to all 2d combinations
   // the histograms are not returned, just use them from memory or use this to create them in a file
@@ -122,18 +122,24 @@ void AliPWG0Helper::CreateProjections(TH3* hist)
   TH1* proj = hist->Project3D("yx");
   proj->SetXTitle(hist->GetXaxis()->GetTitle());
   proj->SetYTitle(hist->GetYaxis()->GetTitle());
+  if (save)
+    proj->Write();
 
   proj = hist->Project3D("zx");
   proj->SetXTitle(hist->GetXaxis()->GetTitle());
   proj->SetYTitle(hist->GetZaxis()->GetTitle());
+  if (save)
+    proj->Write();
 
   proj = hist->Project3D("zy");
   proj->SetXTitle(hist->GetYaxis()->GetTitle());
   proj->SetYTitle(hist->GetZaxis()->GetTitle());
+  if (save)
+    proj->Write();
 }
 
 //____________________________________________________________________
-void AliPWG0Helper::CreateDividedProjections(TH3* hist, TH3* hist2, const char* axis, Bool_t putErrors)
+void AliPWG0Helper::CreateDividedProjections(TH3* hist, TH3* hist2, const char* axis, Bool_t putErrors, Bool_t save)
 {
   // create projections of the 3d hists divides them
   // axis decides to which plane, if axis is 0 to all planes
@@ -141,9 +147,9 @@ void AliPWG0Helper::CreateDividedProjections(TH3* hist, TH3* hist2, const char*
 
   if (axis == 0)
   {
-    CreateDividedProjections(hist, hist2, "yx", putErrors);
-    CreateDividedProjections(hist, hist2, "zx", putErrors);
-    CreateDividedProjections(hist, hist2, "zy", putErrors);
+    CreateDividedProjections(hist, hist2, "yx", putErrors, save);
+    CreateDividedProjections(hist, hist2, "zx", putErrors, save);
+    CreateDividedProjections(hist, hist2, "zy", putErrors, save);
 
     return;
   }
@@ -168,7 +174,10 @@ void AliPWG0Helper::CreateDividedProjections(TH3* hist, TH3* hist2, const char*
     proj2->SetXTitle(GetAxisTitle(hist2, axis[0]));
 
   TH1* division = dynamic_cast<TH1*> (proj->Clone(Form("%s_div_%s", proj->GetName(), proj2->GetName())));
+  //printf("doing axis: %s, x axis has %d %d bins, min %f %f max %f %f\n", axis, division->GetNbinsX(), proj2->GetNbinsX(), division->GetXaxis()->GetBinLowEdge(1), proj2->GetXaxis()->GetBinLowEdge(1), division->GetXaxis()->GetBinUpEdge(division->GetNbinsX()), proj2->GetXaxis()->GetBinUpEdge(proj2->GetNbinsX()));
+  //printf("doing axis: %s, y axis has %d %d bins, min %f %f max %f %f\n", axis, division->GetNbinsY(), proj2->GetNbinsY(), division->GetYaxis()->GetBinLowEdge(1), proj2->GetYaxis()->GetBinLowEdge(1), division->GetYaxis()->GetBinUpEdge(division->GetNbinsY()), proj2->GetYaxis()->GetBinUpEdge(proj2->GetNbinsY()));
   division->Divide(proj2);
+  division->SetTitle(Form("%s divided %s", proj->GetTitle(), proj2->GetTitle()));
 
   if (putErrors)
   {
@@ -176,7 +185,7 @@ void AliPWG0Helper::CreateDividedProjections(TH3* hist, TH3* hist2, const char*
     if (division->GetDimension() == 1)
     {
       Int_t nBins = division->GetNbinsX();
-      for (Int_t i = 0; i <= nBins; ++i)
+      for (Int_t i = 1; i <= nBins; ++i)
         if (proj2->GetBinContent(i) != 0)
           division->SetBinError(i, TMath::Sqrt(proj->GetBinContent(i)) / proj2->GetBinContent(i));
     }
@@ -184,12 +193,19 @@ void AliPWG0Helper::CreateDividedProjections(TH3* hist, TH3* hist2, const char*
     {
       Int_t nBinsX = division->GetNbinsX();
       Int_t nBinsY = division->GetNbinsY();
-      for (Int_t i = 0; i <= nBinsX; ++i)
-        for (Int_t j = 0; j <= nBinsY; ++j)
+      for (Int_t i = 1; i <= nBinsX; ++i)
+        for (Int_t j = 1; j <= nBinsY; ++j)
           if (proj2->GetBinContent(i, j) != 0)
             division->SetBinError(i, j, TMath::Sqrt(proj->GetBinContent(i, j)) / proj2->GetBinContent(i, j));
     }
   }
+
+  if (save)
+  {
+    proj->Write();
+    proj2->Write();
+    division->Write();
+  }
 }
 
 //____________________________________________________________________
index aede164..5d3b9ab 100644 (file)
@@ -18,8 +18,8 @@ class AliPWG0Helper : public TObject
     static Bool_t IsVertexReconstructed(AliESD* aEsd);
     static Bool_t IsPrimaryCharged(TParticle* aParticle, Int_t aTotalPrimaries, Bool_t adebug = kFALSE);
 
-    static void CreateProjections(TH3* hist);
-    static void CreateDividedProjections(TH3* hist, TH3* hist2, const char* axis = 0, Bool_t putErrors = kFALSE);
+    static void CreateProjections(TH3* hist, Bool_t save = kFALSE);
+    static void CreateDividedProjections(TH3* hist, TH3* hist2, const char* axis = 0, Bool_t putErrors = kFALSE, Bool_t save = kFALSE);
     static const char* GetAxisTitle(TH3* hist, const char axis);
     
   protected:
index 70ce577..1578499 100644 (file)
@@ -149,7 +149,7 @@ TChain* CreateESDChain(const char* aDataDir = "ESDfiles.txt", Int_t aRuns = 20,
     in.close();
     
     if (check)
-      outFile.close();
+      outfile.close();
   }
   
   if (chainFriend)
index 2beb96a..315ea26 100644 (file)
@@ -19,6 +19,8 @@
 
 #pragma link C++ class AliPWG0Helper+;
 
+#pragma link C++ class AliCorrection+;
+
 
 
 #endif
index 75458b8..bec2d19 100644 (file)
@@ -6,6 +6,7 @@ HDRS = dNdEta/dNdEtaAnalysis.h \
       AliCorrectionMatrix.h \
       AliCorrectionMatrix2D.h \
       AliCorrectionMatrix3D.h \
+      AliCorrection.h \
       AliPWG0Helper.h
 
 SRCS = $(HDRS:.h=.cxx)