Simplification of container and grid classes.
authorrvernet <rvernet@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 10 Jul 2009 13:36:23 +0000 (13:36 +0000)
committerrvernet <rvernet@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 10 Jul 2009 13:36:23 +0000 (13:36 +0000)
Added several features (eg. axis titles , step labels...)
Removed test/muons (--> PWG3)

28 files changed:
CORRFW/AliCFContainer.cxx
CORRFW/AliCFContainer.h
CORRFW/AliCFDataGrid.cxx
CORRFW/AliCFDataGrid.h
CORRFW/AliCFEffGrid.cxx
CORRFW/AliCFEffGrid.h
CORRFW/AliCFFrame.cxx
CORRFW/AliCFFrame.h
CORRFW/AliCFGrid.cxx [deleted file]
CORRFW/AliCFGrid.h [deleted file]
CORRFW/AliCFGridSparse.cxx
CORRFW/AliCFGridSparse.h
CORRFW/AliCFUnfolding.h
CORRFW/AliCFVGrid.cxx [deleted file]
CORRFW/AliCFVGrid.h [deleted file]
CORRFW/CMake_libCORRFW.txt
CORRFW/CORRFWLinkDef.h
CORRFW/libCORRFW.pkg
CORRFW/test/AliCFRsnTask.C
CORRFW/test/AliCFSingleTrackTask.C
CORRFW/test/AliCFTaskForUnfolding.h
CORRFW/test/AliCFV0Task.C
CORRFW/test/muons/AliCFMuonResTask1.C [deleted file]
CORRFW/test/muons/AliCFMuonResTask1.cxx [deleted file]
CORRFW/test/muons/AliCFMuonResTask1.h [deleted file]
CORRFW/test/testCFContainers.C
CORRFW/test/testSlice.C
CORRFW/test/testUnfolding.C

index d14d664..7c18e54 100644 (file)
@@ -25,7 +25,6 @@
 //
 //
 #include <AliLog.h>
-#include "AliCFGrid.h"
 #include "AliCFGridSparse.h"
 #include "AliCFContainer.h"
 #include "TAxis.h"
@@ -52,42 +51,35 @@ AliCFContainer::AliCFContainer(const Char_t* name, const Char_t* title) :
 }
 
 //____________________________________________________________________
-AliCFContainer::AliCFContainer(const Char_t* name, const Char_t* title,const Int_t nSelSteps, const Int_t nVarIn, const Int_t * nBinIn, const Double_t *binLimitsIn, const Bool_t useSparse) :  
-  AliCFFrame(name,title,nVarIn,nBinIn,binLimitsIn),
-  fNStep(0),
+AliCFContainer::AliCFContainer(const Char_t* name, const Char_t* title, const Int_t nSelSteps, const Int_t nVarIn, const Int_t* nBinIn) :  
+  AliCFFrame(name,title),
+  fNStep(nSelSteps),
   fGrid(0x0)
 {
   //
   // main constructor
   //
 
-  // The selection steps
-  fNStep=nSelSteps;
-
   // The grids 
-  fGrid = new AliCFVGrid*[fNStep]; //the grids at the various selection steps
+  fGrid = new AliCFGridSparse*[fNStep]; //the grids at the various selection steps
   char gname[30];
-  for(Int_t istep=0;istep<fNStep;istep++){
+  for (Int_t istep=0; istep<fNStep; istep++) {
     sprintf(gname,"%s%s%i",GetName(),"_SelStep", istep);
-    if(!useSparse){
-      fGrid[istep] = new AliCFGrid(gname,title,nVarIn,nBinIn,binLimitsIn); 
-      }
-    else{
-      fGrid[istep] = new AliCFGridSparse(gname,title,nVarIn,nBinIn,binLimitsIn); 
-    }
-    fGrid[istep]->SumW2(); 
+    fGrid[istep] = new AliCFGridSparse(gname,title,nVarIn,nBinIn);
+    fGrid[istep]->SumW2();
   }
+  AliInfo(Form("Grids created for %d steps required  \n =>  Don't forget to set the bin limits !!",fNStep));
 }
 //____________________________________________________________________
-AliCFContainer::AliCFContainer(const AliCFContainer& c) : 
-  AliCFFrame(),
-  fNStep(c.fNStep),
-  fGrid(c.fGrid)
+AliCFContainer::AliCFContainer(const AliCFContainer& c) :
+  AliCFFrame(c.fName,c.fTitle),
+  fNStep(0),
+  fGrid(0x0)
 {
   //
   // copy constructor
   //
-  ((AliCFContainer &)c).Copy(*this);
+  c.Copy(*this);
 }
 //____________________________________________________________________
 AliCFContainer::~AliCFContainer()
@@ -95,8 +87,7 @@ AliCFContainer::~AliCFContainer()
   //
   // destructor
   //
-  if(fGrid)delete [] fGrid;
-
+  if (fGrid) delete [] fGrid;
 }
 //____________________________________________________________________
 AliCFContainer &AliCFContainer::operator=(const AliCFContainer &c)
@@ -104,49 +95,27 @@ AliCFContainer &AliCFContainer::operator=(const AliCFContainer &c)
   //
   // assigment operator
   //
-  if (this != &c)
-    ((AliCFContainer &) c).Copy(*this);
+  if (this != &c) c.Copy(*this);
   return *this;
 } 
-//____________________________________________________________________
-void AliCFContainer::SetBinLimits(Int_t varindex, Double_t *array)
-{
-  //
-  // setting the arrays containing the bin limits 
-  //
-  Int_t nbins=fNVarBins[varindex]+1;
-  for(Int_t i=0;i<nbins;i++){
-    fVarBinLimits[fOffset[varindex]+i] =array[i];
-  } 
-  for(Int_t istep=0;istep<fNStep;istep++){
-    fGrid[istep]->SetBinLimits(varindex,array);
-  }
-} 
+
 //____________________________________________________________________
 void AliCFContainer::Copy(TObject& c) const
 {
   //
   // copy function
   //
+  AliCFFrame::Copy(c);
   AliCFContainer& target = (AliCFContainer &) c;
-  target.fNStep=fNStep;
-  target.fNVar=fNVar;
-  target.fNDim=fNDim;
-  target.fNVarBinLimits=fNVarBinLimits;
-  if (fNVarBins)
-    target.fNVarBins = fNVarBins;
-  if (fVarBinLimits)
-    target.fVarBinLimits = fVarBinLimits;
-  if (fGrid)
-    target.fGrid = fGrid;
-    for(Int_t istep=0;istep<fNStep;istep++){
-      for(Int_t iel=0;iel<fNDim;iel++){
-       target.fGrid[istep]->SetElement(iel,fGrid[istep]->GetElement(iel));
-      } 
-    }  
+  target.fNStep = fNStep;
+  target.fGrid  = new AliCFGridSparse*[fNStep];
+  for (Int_t iStep=0; iStep<fNStep; iStep++) {
+    if (fGrid[iStep])  target.fGrid[iStep] = new AliCFGridSparse(*(fGrid[iStep]));
+  }
 }
+
 //____________________________________________________________________
-void AliCFContainer::Fill(Double_t *var, Int_t istep, Double_t weight)
+void AliCFContainer::Fill(const Double_t *var, Int_t istep, Double_t weight)
 {
   //
   // Fills the grid at selection step istep for a set of values of the 
@@ -159,7 +128,7 @@ void AliCFContainer::Fill(Double_t *var, Int_t istep, Double_t weight)
   fGrid[istep]->Fill(var,weight);
 }
 //___________________________________________________________________
-TH1D *AliCFContainer::ShowProjection(Int_t ivar, Int_t istep) const
+TH1D *AliCFContainer::Project(Int_t ivar, Int_t istep) const
 {
   //
   // returns 1-D projection along variable ivar at selection step istep
@@ -168,15 +137,15 @@ TH1D *AliCFContainer::ShowProjection(Int_t ivar, Int_t istep) const
     AliError("Non-existent selection step, return NULL");
     return 0x0;
   }
-  if(ivar >= fNVar || ivar < 0){
-    AliError("Non-existent selection step, return NULL");
+  if(ivar >= GetNVar() || ivar < 0){
+    AliError("Non-existent variable, return NULL");
     return 0x0;
   }
 
   return fGrid[istep]->Project(ivar);
 }
 //___________________________________________________________________
-TH2D *AliCFContainer::ShowProjection(Int_t ivar1, Int_t ivar2, Int_t istep) const
+TH2D *AliCFContainer::Project(Int_t ivar1, Int_t ivar2, Int_t istep) const
 {
   //
   // returns 2-D projection along variables ivar1,ivar2 at selection step istep
@@ -185,15 +154,15 @@ TH2D *AliCFContainer::ShowProjection(Int_t ivar1, Int_t ivar2, Int_t istep) cons
     AliError("Non-existent selection step, return NULL");
     return 0x0;
   }
-  if(ivar1 >= fNVar || ivar1 < 0 || ivar2 >= fNVar || ivar2 < 0){
-    AliError("Non-existent selection step, return NULL");
+  if(ivar1 >= GetNVar() || ivar1 < 0 || ivar2 >= GetNVar() || ivar2 < 0){
+    AliError("Non-existent variable, return NULL");
     return 0x0;
   }
 
   return fGrid[istep]->Project(ivar1,ivar2);
 }
 //___________________________________________________________________
-TH3D *AliCFContainer::ShowProjection(Int_t ivar1, Int_t ivar2, Int_t ivar3, Int_t istep) const
+TH3D *AliCFContainer::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3, Int_t istep) const
 {
   //
   // returns 3-D projection along variables ivar1,ivar2,ivar3 
@@ -203,10 +172,10 @@ TH3D *AliCFContainer::ShowProjection(Int_t ivar1, Int_t ivar2, Int_t ivar3, Int_
     AliError("Non-existent selection step, return NULL");
     return 0x0;
   }
-  if(ivar1 >= fNVar || ivar1 < 0 || 
-     ivar2 >= fNVar || ivar2 < 0 ||
-     ivar3 >= fNVar || ivar3 < 0 ) {
-    AliError("Non-existent selection step, return NULL");
+  if(ivar1 >= GetNVar() || ivar1 < 0 || 
+     ivar2 >= GetNVar() || ivar2 < 0 ||
+     ivar3 >= GetNVar() || ivar3 < 0 ) {
+    AliError("Non-existent variable, return NULL");
     return 0x0;
   }
 
@@ -222,7 +191,7 @@ TH1D *AliCFContainer::ShowSlice(Int_t ivar, Double_t *varMin, Double_t* varMax,
     AliError("Non-existent selection step, return NULL");
     return 0x0;
   }
-  if (ivar >= fNVar || ivar < 0) {
+  if (ivar >= GetNVar() || ivar < 0) {
     AliError("Non-existent variable, return NULL");
     return 0x0;
   }
@@ -238,7 +207,7 @@ TH2D *AliCFContainer::ShowSlice(Int_t ivar1, Int_t ivar2, Double_t *varMin, Doub
     AliError("Non-existent selection step, return NULL");
     return 0x0;
   }
-  if (ivar1 >= fNVar || ivar1 < 0 || ivar2 >= fNVar || ivar2 < 0) {
+  if (ivar1 >= GetNVar() || ivar1 < 0 || ivar2 >= GetNVar() || ivar2 < 0) {
     AliError("Non-existent variable, return NULL");
     return 0x0;
   }
@@ -254,18 +223,18 @@ TH3D *AliCFContainer::ShowSlice(Int_t ivar1, Int_t ivar2, Int_t ivar3, Double_t
     AliError("Non-existent selection step, return NULL");
     return 0x0;
   }
-  if (ivar1 >= fNVar || ivar1 < 0 || ivar2 >= fNVar || ivar2 < 0 || ivar3 >= fNVar || ivar3 < 0) {
+  if (ivar1 >= GetNVar() || ivar1 < 0 || ivar2 >= GetNVar() || ivar2 < 0 || ivar3 >= GetNVar() || ivar3 < 0) {
     AliError("Non-existent variable, return NULL");
     return 0x0;
   }
   return (TH3D*)fGrid[istep]->Slice(ivar1,ivar2,ivar3,varMin,varMax);
 }
 //____________________________________________________________________
-AliCFContainer* AliCFContainer::MakeSlice(Int_t nVars, Int_t* vars, Double_t* varMin, Double_t* varMax) const
+AliCFContainer* AliCFContainer::MakeSlice(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax) const
 {
   //
   // Makes a slice along the "nVars" variables defined in the array "vars[nVars]" for all the container steps.
-  // The ranges of ALL the container variables must be defined in the array varMin[fNVar] and varMax[fNVar]
+  // The ranges of ALL the container variables must be defined in the array varMin[GetNVar()] and varMax[GetNVar()]
   // The function returns a new container of nVars variables.
   //
   Int_t* steps = new Int_t[fNStep];
@@ -276,21 +245,21 @@ AliCFContainer* AliCFContainer::MakeSlice(Int_t nVars, Int_t* vars, Double_t* va
 }
 
 //____________________________________________________________________
-AliCFContainer* AliCFContainer::MakeSlice(Int_t nVars, Int_t* vars, Double_t* varMin, Double_t* varMax, Int_t nSteps, Int_t* steps) const
+AliCFContainer* AliCFContainer::MakeSlice(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Int_t nSteps, const Int_t* steps) const
 {
   //
   // Makes a slice along the "nVars" variables defined in the array "vars[nVars]" for the given "nSteps" defined in "steps[nSteps]".
-  // The ranges of ALL the container variables must be defined in the array varMin[fNVar] and varMax[fNVar]
+  // The ranges of ALL the container variables must be defined in the array varMin[GetNVar()] and varMax[GetNVar()]
   // The function returns a new container of nVars variables.
   //
 
-  if (nVars < 1 || nVars > fNVar)   AliError("Bad number of dimensions required for the slice");
+  if (nVars < 1 || nVars > GetNVar())   AliError("Bad number of dimensions required for the slice");
   if (nSteps< 1 || nSteps> fNStep)  AliError("Bad number of steps required for the slice");
 
   AliInfo(Form("Making a slice in %d dimension(s)",nVars));
 
   // create the output grids
-  AliCFVGrid** grids = new AliCFVGrid*[nSteps] ;
+  AliCFGridSparse** grids = new AliCFGridSparse*[nSteps] ;
   for (Int_t iStep=0; iStep<nSteps; iStep++) grids[iStep] = fGrid[steps[iStep]]->Project(nVars,vars,varMin,varMax);
   
   TAxis ** axis = new TAxis*[nVars];
@@ -351,47 +320,48 @@ Long64_t AliCFContainer::Merge(TCollection* list)
 }
 
 //____________________________________________________________________
-void AliCFContainer::Add(AliCFContainer* aContainerToAdd, Double_t c)
+void AliCFContainer::Add(const AliCFContainer* aContainerToAdd, Double_t c)
 {
   //
   //add the content of container aContainerToAdd to the current one
   //
-  if( (aContainerToAdd->GetNStep()!=fNStep)
-      ||
-      (aContainerToAdd->GetNVar()!=fNVar)
-      ||
-      (aContainerToAdd->GetNDim()!=fNDim)){
-    AliError("Different number of steps/sensitive variables/grid elements: cannot add the containers");
-    return;
-  }
-  for(Int_t istep=0;istep<fNStep;istep++){
+  if ((aContainerToAdd->GetNStep()      != fNStep)          ||
+      (aContainerToAdd->GetNVar()       != GetNVar())       ||
+      (aContainerToAdd->GetNBinsTotal() != GetNBinsTotal()))
+    {
+      AliError("Different number of steps/sensitive variables/grid elements: cannot add the containers");
+      return;
+    }
+  for (Int_t istep=0; istep<fNStep; istep++) {
     fGrid[istep]->Add(aContainerToAdd->GetGrid(istep),c);
   }
 }
 //____________________________________________________________________
-Float_t AliCFContainer::GetOverFlows( Int_t ivar, Int_t istep) const {
+Float_t AliCFContainer::GetOverFlows( Int_t ivar, Int_t istep, Bool_t exclusive) const {
   //
   // Get overflows in variable var at selection level istep
+  // Set 'exclusive' to true for an exclusive check on variable ivar
   //
   if(istep >= fNStep || istep < 0){
     AliError("Non-existent selection step, return -1");
     return -1.;
   }
-  return fGrid[istep]->GetOverFlows(ivar);
+  return fGrid[istep]->GetOverFlows(ivar,exclusive);
 } 
 //____________________________________________________________________
-Float_t AliCFContainer::GetUnderFlows( Int_t ivar, Int_t istep) const {
+Float_t AliCFContainer::GetUnderFlows( Int_t ivar, Int_t istep, Bool_t exclusive) const {
   //
   // Get underflows in variable var at selection level istep
+  // Set 'exclusive' to true for an exclusive check on variable ivar
   //
   if(istep >= fNStep || istep < 0){
     AliError("Non-existent selection step, return -1");
     return -1.;
   }
-  return fGrid[istep]->GetUnderFlows(ivar);
+  return fGrid[istep]->GetUnderFlows(ivar,exclusive);
 } 
 //____________________________________________________________________
-Float_t AliCFContainer::GetEntries( Int_t istep) const {
+Float_t AliCFContainer::GetEntries(Int_t istep) const {
   //
   // Get total entries in variable var at selection level istep
   //
@@ -401,28 +371,28 @@ Float_t AliCFContainer::GetEntries( Int_t istep) const {
   }
   return fGrid[istep]->GetEntries();
 } 
-//____________________________________________________________________
-Int_t AliCFContainer::GetEmptyBins( Int_t istep) const {
-  //
-  // Get empty bins in variable var at selection level istep
-  //
-  if(istep >= fNStep || istep < 0){
-    AliError("Non-existent selection step, return -1");
-    return -1;
-  }
-  return fGrid[istep]->GetEmptyBins();
-} 
-//____________________________________________________________________
-Int_t AliCFContainer::GetEmptyBins( Int_t istep, Double_t *varMin, Double_t* varMax) const {
-  //
-  // Get empty bins in a range in variable var at selection level istep
-  //
-  if(istep >= fNStep || istep < 0){
-    AliError("Non-existent selection step, return -1");
-    return -1;
-  }
-  return fGrid[istep]->GetEmptyBins(varMin,varMax);
-} 
+// //____________________________________________________________________
+// Int_t AliCFContainer::GetEmptyBins(Int_t istep) const {
+//   //
+//   // Get empty bins in variable var at selection level istep
+//   //
+//   if(istep >= fNStep || istep < 0){
+//     AliError("Non-existent selection step, return -1");
+//     return -1;
+//   }
+//   return fGrid[istep]->GetEmptyBins();
+// } 
+// //____________________________________________________________________
+// Int_t AliCFContainer::GetEmptyBins( Int_t istep, Double_t *varMin, Double_t* varMax) const {
+//   //
+//   // Get empty bins in a range in variable var at selection level istep
+//   //
+//   if(istep >= fNStep || istep < 0){
+//     AliError("Non-existent selection step, return -1");
+//     return -1;
+//   }
+//   return fGrid[istep]->GetEmptyBins(varMin,varMax);
+// } 
 //_____________________________________________________________________
 Double_t AliCFContainer::GetIntegral( Int_t istep) const 
 {
@@ -436,36 +406,32 @@ Double_t AliCFContainer::GetIntegral( Int_t istep) const
   return fGrid[istep]->GetIntegral();
 }
 //_____________________________________________________________________
-Double_t AliCFContainer::GetIntegral( Int_t istep, Double_t *varMin, Double_t* varMax ) const 
-{
-  //
-  // Get Integral over the grid in a range at selection level istep
-  //
-  if(istep >= fNStep || istep < 0){
-    AliError("Non-existent selection step, return -1");
-    return -1.;
-  }
-  return fGrid[istep]->GetIntegral(varMin,varMax);
-}
+// Double_t AliCFContainer::GetIntegral( Int_t istep, Double_t *varMin, Double_t* varMax ) const 
+// {
+//   //
+//   // Get Integral over the grid in a range at selection level istep
+//   //
+//   if(istep >= fNStep || istep < 0){
+//     AliError("Non-existent selection step, return -1");
+//     return -1.;
+//   }
+//   return fGrid[istep]->GetIntegral(varMin,varMax);
+// }
 //_____________________________________________________________________
 void AliCFContainer::SetRangeUser(Int_t ivar, Double_t varMin, Double_t varMax, Int_t istep) 
 {
   //
   // set axis range at step istep
   //
-  if ( strcmp(fGrid[istep]->ClassName(),"AliCFGrid") ==0 ) {
-    AliWarning("Could not AliCFGrid::SetRangeUser(), function not implemented");
-    return;
-  }
   if (istep >= fNStep || istep < 0){
     AliError("Non-existent selection step");
     return ;
   }
-  if (ivar >= fNVar || ivar < 0){
+  if (ivar >= GetNVar() || ivar < 0){
     AliError("Non-existent selection var");
     return ;
   }
-  ((AliCFGridSparse*)fGrid[istep])->SetRangeUser(ivar,varMin,varMax);
+  fGrid[istep]->SetRangeUser(ivar,varMin,varMax);
 }
 
 //_____________________________________________________________________
@@ -474,10 +440,6 @@ void AliCFContainer::SetRangeUser(Double_t* varMin, Double_t* varMax, Int_t iste
   //
   // set all axis ranges at step istep according to varMin and varMax values
   //
-  if ( strcmp(fGrid[istep]->ClassName(),"AliCFGrid") ==0 ) {
-    AliWarning("Could not AliCFGrid::SetRangeUser(), function not implemented");
-    return;
-  }
   if (istep >= fNStep || istep < 0){
     AliError("Non-existent selection step");
     return ;
index c361414..83fe538 100644 (file)
 //--------------------------------------------------------------------//
 
 #include "AliCFFrame.h"
+#include "AliCFGridSparse.h"
 
 class TH1D;
 class TH2D;
 class TH3D;
-class AliCFVGrid;
 class TCollection;
 
 class AliCFContainer : public AliCFFrame
@@ -23,50 +23,109 @@ class AliCFContainer : public AliCFFrame
  public:
   AliCFContainer();
   AliCFContainer(const Char_t* name,const Char_t* title);
-  AliCFContainer(const Char_t* name, const Char_t* title,const Int_t nSelStep, const Int_t nVarIn, const Int_t* nBinIn, const Double_t  *binLimitsIn=0, const Bool_t useSparse = kTRUE);
+  AliCFContainer(const Char_t* name, const Char_t* title,const Int_t nSelStep, const Int_t nVarIn, const Int_t* nBinIn);
   AliCFContainer(const AliCFContainer& c);
-  
-  virtual ~AliCFContainer();
   AliCFContainer& operator=(const AliCFContainer& corr);
-  virtual Int_t GetNStep() const {return fNStep;};
+  virtual void Copy(TObject& c) const;
+
+  virtual ~AliCFContainer();
+
+  // AliCFFrame functions
+  virtual Int_t      GetNVar()                                       const {return fGrid[0]->GetNVar();}
+  virtual void       PrintBinLimits()                                const {fGrid[0]->PrintBinLimits();}
+  virtual void       PrintNBins()                                    const {fGrid[0]->PrintNBins();}
+  virtual void       SetBinLimits(Int_t ivar, const Double_t * array) ;
+  virtual void       GetBinLimits(Int_t ivar, Double_t * array)      const {return fGrid[0]->GetBinLimits(ivar,array);}
+  virtual Double_t * GetBinLimits(Int_t ivar)                        const {return fGrid[0]->GetBinLimits(ivar);}
+  virtual Long_t     GetNBinsTotal()                                 const {return fGrid[0]->GetNBinsTotal()*fNStep;}
+  virtual Int_t      GetNBins(Int_t ivar)                            const {return fGrid[0]->GetNBins(ivar);}
+  virtual Int_t    * GetNBins()                                      const {return fGrid[0]->GetNBins();}
+  virtual Float_t    GetBinCenter(Int_t ivar,Int_t ibin)             const {return fGrid[0]->GetBinCenter(ivar,ibin);}
+  virtual Float_t    GetBinSize  (Int_t ivar,Int_t ibin)             const {return fGrid[0]->GetBinSize  (ivar,ibin);}
+
+  //virtual void       GetBinCenters(const Int_t *ibin, const Double_t *binCenter) const {return fGrid[0]->GetBinCenters(ibin,binCenter);}
+  //virtual void       GetBinSizes(const Int_t *ibin, const Double_t *binSizes)    const {return fGrid[0]->GetBinSizes(ibin,binSizes);}
+
+  //probably not needed anymore
+  //virtual Int_t      GetBinIndex(const Int_t *ibin)                  const {return fGrid[0]->GetBinIndex(ibin);}
+  //virtual void       GetBinIndex(Int_t iel, const Int_t *ibin)       const {return fGrid[0]->GetBinIndex(iel,ibin);}
+  //virtual Int_t      GetBinIndex(Int_t ivar, Int_t ind)              const {return fGrid[0]->GetBinIndex(ivar,ind);}
+
+  virtual TAxis       * GetAxis(Int_t ivar, Int_t istep) const {return fGrid[istep]->GetAxis(ivar);}
+  virtual void          SetVarTitle (Int_t ivar,  const Char_t* title) ;
+  virtual void          SetStepTitle(Int_t istep, const Char_t* title) ;
+  virtual const Char_t* GetVarTitle (Int_t ivar)  const {return GetAxis(ivar,0)->GetTitle();}
+  virtual const Char_t* GetStepTitle(Int_t istep) const {return fGrid[istep]->GetTitle();}
+  virtual Int_t         GetStep(const Char_t* title) const ; // returns the step     corresponding to the given title
+  virtual Int_t         GetVar (const Char_t* title) const ; // returns the variable corresponding to the given title
 
+  virtual Int_t GetNStep() const {return fNStep;};
   virtual void  SetNStep(Int_t nStep) {fNStep=nStep;}
-  virtual void  SetBinLimits(Int_t varindex, Double_t * array);
+  virtual void  Fill(const Double_t *var, Int_t istep, Double_t weight=1.) ;
 
-  virtual void  Fill(Double_t *var, Int_t istep, Double_t weight=1.);
+  virtual Float_t  GetOverFlows (Int_t var,Int_t istep,Bool_t excl=kFALSE) const;
+  virtual Float_t  GetUnderFlows(Int_t var,Int_t istep,Bool_t excl=kFALSE) const ;
+  virtual Float_t  GetEntries  (Int_t istep) const ;
+  virtual Long_t   GetEmptyBins(Int_t istep) const {return fGrid[istep]->GetEmptyBins();}
+  //virtual Int_t    GetEmptyBins(Int_t istep, Double_t *varMin,Double_t *varMax) const ;
+  virtual Double_t GetIntegral (Int_t istep) const ;
+  //virtual Double_t GetIntegral (Int_t istep, Double_t *varMin,Double_t *varMax) const ;
 
-  virtual Float_t GetOverFlows(Int_t var,Int_t istep) const;
-  virtual Float_t GetUnderFlows(Int_t var,Int_t istep)const ;
-  virtual Float_t GetEntries(Int_t istep)const ;
-  virtual Int_t   GetEmptyBins(Int_t istep)const ;
-  virtual Int_t   GetEmptyBins(Int_t istep, Double_t *varMin,Double_t *varMax) const ;
-  virtual Double_t GetIntegral(Int_t istep) const ;
-  virtual Double_t GetIntegral(Int_t istep, Double_t *varMin,Double_t *varMax) const ;
-  //basic operations
 
-  virtual void Copy(TObject& c) const;
-  virtual void Add(AliCFContainer* aContainerToAdd, Double_t c=1.);
+  //basic operations
+  virtual void     Add(const AliCFContainer* aContainerToAdd, Double_t c=1.);
   virtual Long64_t Merge(TCollection* list);
 
-  virtual TH1D* ShowProjection( Int_t ivar, Int_t istep) const;
-  virtual TH2D* ShowProjection( Int_t ivar1, Int_t ivar2, Int_t istep) const;
-  virtual TH3D* ShowProjection( Int_t ivar1, Int_t ivar2,Int_t ivar3, Int_t istep) const;
+  virtual TH1D* ShowProjection( Int_t ivar, Int_t istep)                           const {return Project(ivar             ,istep);}
+  virtual TH2D* ShowProjection( Int_t ivar1, Int_t ivar2, Int_t istep)             const {return Project(ivar1,ivar2      ,istep);}
+  virtual TH3D* ShowProjection( Int_t ivar1, Int_t ivar2,Int_t ivar3, Int_t istep) const {return Project(ivar1,ivar2,ivar3,istep);}
+  virtual TH1D* Project( Int_t ivar, Int_t istep) const;
+  virtual TH2D* Project( Int_t ivar1, Int_t ivar2, Int_t istep) const;
+  virtual TH3D* Project( Int_t ivar1, Int_t ivar2,Int_t ivar3, Int_t istep) const;
   virtual TH1D* ShowSlice( Int_t ivar, Double_t *varMin, Double_t *varMax, Int_t istep) const;
   virtual TH2D* ShowSlice( Int_t ivar1, Int_t ivar2, Double_t *varMin, Double_t *varMax, Int_t istep) const;
   virtual TH3D* ShowSlice( Int_t ivar1, Int_t ivar2, Int_t ivar3, Double_t *varMin, Double_t *varMax, Int_t istep) const;
-  virtual AliCFContainer*  MakeSlice (Int_t nVars, Int_t* vars, Double_t* varMin, Double_t* varMax) const ;
-  virtual AliCFContainer*  MakeSlice (Int_t nVars, Int_t* vars, Double_t* varMin, Double_t* varMax, Int_t nStep, Int_t* steps) const ;
+  virtual AliCFContainer*  MakeSlice (Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax) const ;
+  virtual AliCFContainer*  MakeSlice (Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Int_t nStep, const Int_t* steps) const ;
   virtual void  SetRangeUser(Int_t ivar, Double_t varMin, Double_t varMax, Int_t istep) ;
   virtual void  SetRangeUser(Double_t* varMin, Double_t* varMax, Int_t istep) ;
-  virtual void  SetGrid(Int_t step, AliCFVGrid* grid) {fGrid[step]=grid;}
-  virtual AliCFVGrid * GetGrid(Int_t istep) const {return (AliCFVGrid*)fGrid[istep];};
+  virtual void  SetGrid(Int_t step, AliCFGridSparse* grid) {fGrid[step]=grid;}
+  virtual AliCFGridSparse * GetGrid(Int_t istep) const {return fGrid[istep];};
   
  private:
   Int_t    fNStep; //number of selection steps
-  AliCFVGrid **fGrid;//[fNStep]
+  AliCFGridSparse **fGrid;//[fNStep]
   
-  ClassDef(AliCFContainer,4);
+  ClassDef(AliCFContainer,5);
 };
-    
+
+inline void AliCFContainer::SetBinLimits(Int_t ivar, const Double_t* array) {
+  for (Int_t iStep=0; iStep<GetNStep(); iStep++) {
+    fGrid[iStep]->SetBinLimits(ivar,array);
+  }
+}
+
+inline void AliCFContainer::SetVarTitle(Int_t ivar, const Char_t* title) {
+  for (Int_t iStep=0; iStep<fNStep; iStep++) {
+    GetAxis(ivar,iStep)->SetTitle(title);
+  }
+}
+
+inline void AliCFContainer::SetStepTitle(Int_t istep, const Char_t* title) {
+  fGrid[istep]->SetTitle(title);
+}
+
+inline Int_t AliCFContainer::GetStep(const Char_t* title) const {
+  TString str(title);
+  for (Int_t iStep=0; iStep<fNStep; iStep++) {
+    if (!str.CompareTo(GetStepTitle(iStep))) return iStep;
+  }
+  AliError("Step not found");
+  return -1;
+}
+
+inline Int_t AliCFContainer::GetVar(const Char_t* title) const {
+  return fGrid[0]->GetVar(title);
+}
 #endif
 
index 6ae8abe..c50243d 100644 (file)
@@ -55,8 +55,8 @@ AliCFDataGrid::AliCFDataGrid(const Char_t* name,const Char_t* title) :
 }
 
 //____________________________________________________________________
-AliCFDataGrid::AliCFDataGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn, const Double_t *binLimitsIn) :  
-  AliCFGridSparse(name,title,nVarIn,nBinIn,binLimitsIn),
+AliCFDataGrid::AliCFDataGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn) :
+  AliCFGridSparse(name,title,nVarIn,nBinIn),
   fSelData(-1),
   fContainer(0x0)
 {
@@ -65,22 +65,21 @@ AliCFDataGrid::AliCFDataGrid(const Char_t* name, const Char_t* title, const Int_
   //
   SumW2();// errors saved
 }
+
 //____________________________________________________________________
 AliCFDataGrid::AliCFDataGrid(const Char_t* name, const Char_t* title, const AliCFContainer &c) :  
   AliCFGridSparse(name,title),
   fSelData(-1),
-  fContainer(0x0)
+  fContainer(&c)
 {
   //
   // main constructor
   //
-
-  //assign the container;
-  fContainer=&c;
-  fNVar = c.GetNVar();
 }
+
 //____________________________________________________________________
-AliCFDataGrid::AliCFDataGrid(const AliCFDataGrid& data) :   AliCFGridSparse(),
+AliCFDataGrid::AliCFDataGrid(const AliCFDataGrid& data) : 
+  AliCFGridSparse(data),
   fSelData(-1),
   fContainer(0x0)
 {
@@ -97,18 +96,18 @@ AliCFDataGrid::~AliCFDataGrid()
   // destructor
   //
 }
+
 //____________________________________________________________________
 AliCFDataGrid &AliCFDataGrid::operator=(const AliCFDataGrid &c)
 {
   //
   // assigment operator
   //
-  if (this != &c)
-    ((AliCFDataGrid &) c).Copy(*this);
+  if (this != &c) c.Copy(*this);
   return *this;
 } 
-//____________________________________________________________________
 
+//____________________________________________________________________
 void AliCFDataGrid::SetMeasured(Int_t istep)
 {
   //
@@ -117,7 +116,7 @@ void AliCFDataGrid::SetMeasured(Int_t istep)
   
   fSelData = istep ;
   //simply clones the container's data at specified step
-  fData = (THnSparse*) ((AliCFGridSparse*)fContainer->GetGrid(istep))->GetGrid()->Clone();
+  fData = (THnSparse*) fContainer->GetGrid(istep)->GetGrid()->Clone();
   SumW2();
   AliInfo(Form("retrieving measured data from Container %s at selection step %i.",fContainer->GetName(),fSelData));
 } 
@@ -128,7 +127,7 @@ void AliCFDataGrid::ApplyEffCorrection(const AliCFEffGrid &c)
   //
   // Apply the efficiency correction
   //
-  if(c.GetNVar()!=fNVar){
+  if (c.GetNVar()!=GetNVar()) {
     AliInfo("Different number of variables, cannot apply correction");
     return;
   }
@@ -142,21 +141,20 @@ void AliCFDataGrid::ApplyBGCorrection(const AliCFDataGrid &c)
   //
   // Apply correction for background
   //
-  if(c.GetNVar()!=fNVar){
+  if (c.GetNVar()!=GetNVar()) {
     AliInfo("Different number of variables, cannot apply correction");
     return;
   }
   Add(&c);
   AliInfo(Form("background %s subtracted from data %s.",c.GetName(),GetName()));
 }
+
 //____________________________________________________________________
 void AliCFDataGrid::Copy(TObject& c) const
 {
   // copy function
-
   Copy(c);
   AliCFDataGrid& target = (AliCFDataGrid &) c;
   target.fContainer=fContainer;
   target.fSelData=fSelData;
-
 }
index 5fc272d..99f6c92 100644 (file)
@@ -19,18 +19,18 @@ class AliCFDataGrid : public AliCFGridSparse
  public:
   AliCFDataGrid();
   AliCFDataGrid(const Char_t* name,const Char_t* title);
-  AliCFDataGrid(const Char_t* name,const Char_t* title, const Int_t nVarIn, const Int_t* nBinIn, const Double_t  *binLimitsIn=0);
-  AliCFDataGrid(const Char_t* name,const Char_t* title,const AliCFContainer &c);
+  AliCFDataGrid(const Char_t* name,const Char_t* title, const AliCFContainer &c);
+  AliCFDataGrid(const Char_t* name,const Char_t* title, const Int_t nVarIn, const Int_t* nBinIn);
   AliCFDataGrid(const AliCFDataGrid& c);
-  
-  virtual ~AliCFDataGrid();
   AliCFDataGrid& operator=(const AliCFDataGrid& c);
+  virtual ~AliCFDataGrid();
+
   virtual Int_t GetSelDataStep() const {return fSelData;};
 
   // Methods for handling/correcting data 
 
   virtual void  SetMeasured(Int_t istep);
-  virtual const AliCFVGrid*  GetData() {return (AliCFVGrid*)fContainer->GetGrid(fSelData);};
+  virtual const AliCFGridSparse*  GetData() {return fContainer->GetGrid(fSelData);};
   virtual void  ApplyEffCorrection(const AliCFEffGrid &eff);
   virtual void  ApplyBGCorrection(const AliCFDataGrid &c);
   virtual void  SetContainer(const AliCFContainer &c) {fContainer=&c;};
@@ -45,4 +45,3 @@ class AliCFDataGrid : public AliCFGridSparse
 };
     
 #endif
-
index e6a7075..a8f50a0 100644 (file)
@@ -15,7 +15,7 @@
  **************************************************************************/
 //--------------------------------------------------------------------//
 //                                                                    //
-// AliCFEffGrid Class                                              //
+// AliCFEffGrid Class                                                 //
 // Class to handle efficiency grids                                   // 
 //                                                                    //
 // -- Author : S.Arcelli                                              //
@@ -48,8 +48,8 @@ AliCFEffGrid::AliCFEffGrid() :
 }
 
 //____________________________________________________________________
-AliCFEffGrid::AliCFEffGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn, const Double_t *binLimitsIn) :  
-  AliCFGridSparse(name,title,nVarIn,nBinIn,binLimitsIn),
+AliCFEffGrid::AliCFEffGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn) :
+  AliCFGridSparse(name,title,nVarIn,nBinIn),
   fContainer(0x0),
   fSelNum(-1),
   fSelDen(-1)
@@ -61,7 +61,7 @@ AliCFEffGrid::AliCFEffGrid(const Char_t* name, const Char_t* title, const Int_t
 }
 //____________________________________________________________________
 AliCFEffGrid::AliCFEffGrid(const Char_t* name, const Char_t* title, const AliCFContainer &c) :  
-  AliCFGridSparse(name,title,c.GetNVar(),c.GetNBins(),c.GetBinLimits()),
+  AliCFGridSparse(name,title,c.GetNVar(),c.GetNBins()),
   fContainer(NULL),
   fSelNum(-1),
   fSelDen(-1)
@@ -72,9 +72,14 @@ AliCFEffGrid::AliCFEffGrid(const Char_t* name, const Char_t* title, const AliCFC
   SumW2();
   //assign the container;
   fContainer=&c;
+  for (Int_t iVar=0; iVar<GetNVar(); iVar++) {
+    SetBinLimits(iVar,GetBinLimits(iVar));
+  }
+  for (Int_t iVar=0; iVar<GetNVar(); iVar++) SetVarTitle(iVar,c.GetVarTitle(iVar));
 }
 //____________________________________________________________________
-AliCFEffGrid::AliCFEffGrid(const AliCFEffGrid& eff) : AliCFGridSparse(),
+AliCFEffGrid::AliCFEffGrid(const AliCFEffGrid& eff) : 
+  AliCFGridSparse(eff),
   fContainer(0x0),
   fSelNum(-1),
   fSelDen(-1)
@@ -99,12 +104,11 @@ AliCFEffGrid &AliCFEffGrid::operator=(const AliCFEffGrid &eff)
   //
   // assigment operator
   //
-  if (this != &eff)
-    ((AliCFEffGrid &) eff).Copy(*this);
+  if (this != &eff) eff.Copy(*this);
   return *this;
 } 
-//____________________________________________________________________
 
+//____________________________________________________________________
 void AliCFEffGrid::CalculateEfficiency(Int_t istep1,Int_t istep2, Option_t *option)
 {
   //
@@ -117,12 +121,13 @@ void AliCFEffGrid::CalculateEfficiency(Int_t istep1,Int_t istep2, Option_t *opti
 
   fSelNum=istep1;
   fSelDen=istep2;
-  AliCFVGrid *num=GetNum();
-  AliCFVGrid *den=GetDen();
+  AliCFGridSparse *num=GetNum();
+  AliCFGridSparse *den=GetDen();
   num->SumW2();
   den->SumW2();
   this->SumW2();
   this->Divide(num,den,1.,1.,option);
+  SetTitle(Form("Efficiency: %s / %s",fContainer->GetStepTitle(istep1),fContainer->GetStepTitle(istep2)));
 
   AliInfo(Form("Efficiency calculated for steps %i and %i.",fSelNum,fSelDen));
 } 
@@ -147,76 +152,81 @@ Double_t AliCFEffGrid::GetAverage() const
   return val;
 } 
 //_____________________________________________________________________
-Double_t AliCFEffGrid::GetAverage(Double_t *varMin, Double_t* varMax ) const 
-{
-  //
-  // Get ave efficiency in a range
-  // (may not work properly, should be modified)
+// Double_t AliCFEffGrid::GetAverage(const Double_t *varMin, const Double_t* varMax ) const 
+// {
+//   //
+//   // Get ave efficiency in a range
+//   // (may not work properly, should be modified)
 
-  Double_t val=0;
-  Int_t *indexMin = new Int_t[fNVar];
-  Int_t *indexMax = new Int_t[fNVar];
-  Int_t *index    = new Int_t[fNVar];
+//   Double_t val=0;
+//   Int_t *indexMin = new Int_t[GetNVar()];
+//   Int_t *indexMax = new Int_t[GetNVar()];
+//   Int_t *index    = new Int_t[GetNVar()];
   
-  //Find out the min and max bins
+//   //Find out the min and max bins
   
-  for(Int_t i=0;i<fNVar;i++){
-    Double_t xmin=varMin[i]; // the min values  
-    Double_t xmax=varMax[i]; // the max values  
-    Int_t nbins=fNVarBins[i]+1;
-    Double_t *bins=new Double_t[nbins];
-    for(Int_t ibin =0;ibin<nbins;ibin++){
-      bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
-    }
-    indexMin[i] = TMath::BinarySearch(nbins,bins,xmin);
-    indexMax[i] = TMath::BinarySearch(nbins,bins,xmax);
-    if(xmax>=bins[nbins-1]){
-      indexMax[i]=indexMax[i]-1;
-    }  
-    delete [] bins;
-  }
+//   for(Int_t i=0;i<GetNVar();i++){
+//     Double_t xmin=varMin[i]; // the min values  
+//     Double_t xmax=varMax[i]; // the max values  
+//     Int_t nbins = GetNBins(i)+1;
+// //     Double_t *bins = new Double_t[nbins];
+// //     for (Int_t ibin =0; ibin<nbins; ibin++) {
+// //       bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
+// //     }
+//     bins = GetBinLimits(i);
+//     indexMin[i] = TMath::BinarySearch(nbins,bins,xmin);
+//     indexMax[i] = TMath::BinarySearch(nbins,bins,xmax);
+//     if(xmax>=bins[nbins-1]){
+//       indexMax[i]=indexMax[i]-1;
+//     }  
+//     delete [] bins;
+//   }
   
-  Double_t valnum=0;
-  Double_t valden=0;
-  for(Int_t i=0;i<fNDim;i++){
-    for (Int_t j=0;j<fNVar;j++)index[j]=GetBinIndex(j,i);
-    Bool_t isIn=kTRUE;
-    for (Int_t j=0;j<fNVar;j++){
-      if(!(index[j]>=indexMin[j] && index[j]<=indexMax[j]))isIn=kFALSE;   
-    }
-    if(isIn){
-      valnum+=GetNum()->GetElement(i);
-      valden+=GetDen()->GetElement(i);
-    }
-  } 
-  delete [] index;
-  delete [] indexMin;
-  delete [] indexMax;
-  if(valden>0)val=valnum/valden;
-  AliInfo(Form(" the Average Efficiency = %f ",val)); 
-  return val;
-} 
+//   Double_t valnum=0;
+//   Double_t valden=0;
+//   for (Int_t i=0; i<fNDim; i++) {
+//     for (Int_t j=0; j<GetNVar(); j++) index[j]=GetBinIndex(j,i);
+//     Bool_t isIn=kTRUE;
+//     for (Int_t j=0;j<GetNVar();j++) {
+//       if(!(index[j]>=indexMin[j] && index[j]<=indexMax[j]))isIn=kFALSE;   
+//     }
+//     if(isIn){
+//       valnum+=GetNum()->GetElement(i);
+//       valden+=GetDen()->GetElement(i);
+//     }
+//   } 
+//   delete [] index;
+//   delete [] indexMin;
+//   delete [] indexMax;
+//   if(valden>0)val=valnum/valden;
+//   AliInfo(Form(" the Average Efficiency = %f ",val)); 
+//   return val;
+// } 
 //____________________________________________________________________
-void AliCFEffGrid::Copy(TObject& eff) const
-{
-  //
-  // copy function
-  //
-  Copy(eff);
-  AliCFEffGrid& target = (AliCFEffGrid &) eff;
+// void AliCFEffGrid::Copy(TObject& eff) const
+// {
+//   //
+//   // copy function
+//   //
+//   Copy(eff);
+//   AliCFEffGrid& target = (AliCFEffGrid &) eff;
   
-  target.fSelNum=fSelNum; 
-  target.fSelDen=fSelDen; 
-  if(fContainer)
-    target.fContainer=fContainer;
-}
+//   target.fSelNum=fSelNum; 
+//   target.fSelDen=fSelDen; 
+//   if(fContainer)
+//     target.fContainer=fContainer;
+// }
 //___________________________________________________________________
 TH1D *AliCFEffGrid::Project(Int_t ivar) const
 {
   //
   // Make a 1D projection along variable ivar 
   //
+  
+  if (fSelNum<0 || fSelDen<0) {
+    AliError("You must call CalculateEfficiency() first !");
+    return 0x0;
+  }
   const Int_t nDim = 1 ;
   Int_t dim[nDim] = {ivar} ;
   THnSparse* hNum = ((AliCFGridSparse*)GetNum())->GetGrid()->Projection(nDim,dim);
@@ -224,7 +234,10 @@ TH1D *AliCFEffGrid::Project(Int_t ivar) const
   THnSparse* ratio = (THnSparse*)hNum->Clone();
   ratio->Divide(hNum,hDen,1.,1.,"B");
   delete hNum; delete hDen;
-  return ratio->Projection(0);
+  TH1D* h = ratio->Projection(0);
+  h->SetXTitle(GetVarTitle(ivar));
+  h->SetTitle(Form("%s projected on %s",GetTitle(),GetVarTitle(ivar)));
+  return h ;
 } 
 //___________________________________________________________________
 TH2D *AliCFEffGrid::Project(Int_t ivar1,Int_t ivar2) const
@@ -233,6 +246,10 @@ TH2D *AliCFEffGrid::Project(Int_t ivar1,Int_t ivar2) const
   // Make a 2D projection along variable ivar1,ivar2 
   //
   
+  if (fSelNum<0 || fSelDen<0) {
+    AliError("You must call CalculateEfficiency() first !");
+    return 0x0;
+  }
   const Int_t nDim = 2 ;
   Int_t dim[nDim] = {ivar1,ivar2} ;
   THnSparse* hNum = ((AliCFGridSparse*)GetNum())->GetGrid()->Projection(nDim,dim);
@@ -240,7 +257,11 @@ TH2D *AliCFEffGrid::Project(Int_t ivar1,Int_t ivar2) const
   THnSparse* ratio = (THnSparse*)hNum->Clone();
   ratio->Divide(hNum,hDen,1.,1.,"B");
   delete hNum; delete hDen;
-  return ratio->Projection(0,1);
+  TH2D* h = ratio->Projection(0,1);
+  h->SetXTitle(GetVarTitle(ivar1));
+  h->SetYTitle(GetVarTitle(ivar2));
+  h->SetTitle(Form("%s projected on %s-%s",GetTitle(),GetVarTitle(ivar1),GetVarTitle(ivar2)));
+  return h;
 } 
 //___________________________________________________________________
 TH3D *AliCFEffGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
@@ -249,6 +270,10 @@ TH3D *AliCFEffGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
   // Make a 3D projection along variable ivar1,ivar2,ivar3 
   //
 
+  if (fSelNum<0 || fSelDen<0) {
+    AliError("You must call CalculateEfficiency() first !");
+    return 0x0;
+  }
   const Int_t nDim = 3 ;
   Int_t dim[nDim] = {ivar1,ivar2,ivar3} ;
   THnSparse* hNum = ((AliCFGridSparse*)GetNum())->GetGrid()->Projection(nDim,dim);
@@ -256,15 +281,21 @@ TH3D *AliCFEffGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
   THnSparse* ratio = (THnSparse*)hNum->Clone();
   ratio->Divide(hNum,hDen,1.,1.,"B");
   delete hNum; delete hDen;
-  return ratio->Projection(0,1,2);
+  TH3D* h = ratio->Projection(0,1,2);
+  h->SetXTitle(GetVarTitle(ivar1));
+  h->SetYTitle(GetVarTitle(ivar2));
+  h->SetZTitle(GetVarTitle(ivar3));
+  h->SetTitle(Form("%s projected on %s-%s-%s",GetTitle(),GetVarTitle(ivar1),GetVarTitle(ivar2),GetVarTitle(ivar3)));
+  return h;
 } 
 //___________________________________________________________________
-AliCFEffGrid* AliCFEffGrid::MakeSlice(Int_t nVars, Int_t* vars, Double_t* varMin, Double_t* varMax, Int_t numStep, Int_t denStep) const {
+AliCFEffGrid* AliCFEffGrid::MakeSlice(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Int_t numStep, Int_t denStep) const {
   //
   // Makes a slice along the "nVars" variables defined in the array "vars[nVars]" for all the container steps.
   // The ranges of ALL the container variables must be defined in the array varMin[fNVar] and varMax[fNVar].
   // This function returns the effiency relative to this new 'sliced' container, between steps defined in numStep and denStep
   //
+  
   AliCFContainer* cont = fContainer->MakeSlice(nVars,vars,varMin,varMax);
   AliCFEffGrid  * eff  = new AliCFEffGrid(Form("%s_sliced",GetName()), Form("%s_sliced",GetTitle()), *cont);
   eff->CalculateEfficiency(numStep,denStep);
index 3349e3b..7bc2d65 100644 (file)
@@ -3,12 +3,12 @@
 
 /* $Id$ */
 
-//--------------------------------------------------------------------//
-//                                                                    //
+//-----------------------------------------------------------------//
+//                                                                 //
 // AliCFEffGrid Class                                              //
-// Class to handle efficiency grids                                   // 
-//                                                                    //
-//--------------------------------------------------------------------//
+// Class to handle efficiency grids                                // 
+//                                                                 //
+//-----------------------------------------------------------------//
 
 #include "AliCFGridSparse.h"
 #include "AliCFContainer.h"
@@ -20,36 +20,36 @@ class AliCFEffGrid : public AliCFGridSparse
 {
  public:
   AliCFEffGrid();
-  AliCFEffGrid(const Char_t* name,const Char_t* title, const Int_t nVarIn, const Int_t* nBinIn, const Double_t  *binLimitsIn=0);
+  AliCFEffGrid(const Char_t* name,const Char_t* title, const Int_t nVarIn, const Int_t* nBinIn);
   AliCFEffGrid(const Char_t* name,const Char_t* title,const AliCFContainer &c);
-  AliCFEffGrid(const AliCFEffGrid& eff);
-  
   virtual ~AliCFEffGrid();
+  AliCFEffGrid(const AliCFEffGrid& eff);
   AliCFEffGrid& operator=(const AliCFEffGrid& eff);
+  
   virtual Double_t GetAverage() const ;
-  virtual Double_t GetAverage(Double_t *varMin,Double_t *varMax) const ;
+  //virtual Double_t GetAverage(const Double_t *varMin, const Double_t *varMax) const {AliInfo("to be implemented properly"); return 0.;}
   virtual Int_t GetSelNumStep() const {return fSelNum;};
   virtual Int_t GetSelDenStep() const {return fSelDen;};
   virtual TH1D* Project( Int_t ivar) const;
   virtual TH2D* Project( Int_t ivar1, Int_t ivar2) const;
   virtual TH3D* Project( Int_t ivar1, Int_t ivar2,Int_t ivar3) const;
-  virtual AliCFEffGrid* Project(Int_t,Int_t*,Double_t*,Double_t*) const {AliWarning("Function not to be used"); return 0x0;} //not to be used.
-  virtual AliCFEffGrid* MakeSlice(Int_t nVars,Int_t* vars, Double_t* varMin,Double_t* varMax, Int_t numStep, Int_t denStep) const;
+  virtual AliCFEffGrid* Project(Int_t,const Int_t*, const Double_t*, const Double_t*) const {AliWarning("Function not to be used"); return 0x0;}
+  virtual AliCFEffGrid* MakeSlice(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Int_t numStep, Int_t denStep) const;
 
   //Efficiency calculation
-  virtual void  CalculateEfficiency(Int_t istep1, Int_t istep2, Option_t *option ="B");
-  virtual AliCFVGrid*  GetNum() const {return (AliCFVGrid*)fContainer->GetGrid(fSelNum);};
-  virtual AliCFVGrid*  GetDen() const {return (AliCFVGrid*)fContainer->GetGrid(fSelDen);};
+  virtual void  CalculateEfficiency(Int_t istep1, Int_t istep2, Option_t *option ="B" /*binomial*/);
+  virtual AliCFGridSparse*  GetNum() const {return fContainer->GetGrid(fSelNum);};
+  virtual AliCFGridSparse*  GetDen() const {return fContainer->GetGrid(fSelDen);};
   virtual void  SetContainer(const AliCFContainer &c) {fContainer=&c;};
 
-  //basic operations
-  virtual void Copy(TObject& eff) const;
+/*   //basic operations */
+/*   virtual void Copy(TObject& eff) const; */
  
   
  private:
-  const    AliCFContainer *fContainer; //pointer to the input AliContainer
-  Int_t fSelNum; //numerator selection step
-  Int_t fSelDen; //denominator selection step
+  const AliCFContainer *fContainer; //pointer to the input AliContainer
+  Int_t fSelNum;                    //numerator selection step
+  Int_t fSelDen;                    //denominator selection step
   
   ClassDef(AliCFEffGrid,1);
 };
index 3142e7b..6b90cbd 100644 (file)
@@ -37,325 +37,15 @@ ClassImp(AliCFFrame)
 
 //____________________________________________________________________
 AliCFFrame::AliCFFrame() : 
-  TNamed(),
-  fNVar(0),
-  fNDim(0),
-  fNVarBinLimits(0),
-  fNVarBins(0x0),
-  fIndex(0x0),
-  fProduct(0x0),
-  fOffset(0x0),
-  fVarBinLimits(0x0)
+  TNamed()
 {
   // default constructor
 }
+
 //____________________________________________________________________
 AliCFFrame::AliCFFrame(const Char_t* name, const Char_t* title) : 
-  TNamed(name,title),
-  fNVar(0),
-  fNDim(0),
-  fNVarBinLimits(0),
-  fNVarBins(0x0),
-  fIndex(0x0),
-  fProduct(0x0),
-  fOffset(0x0),
-  fVarBinLimits(0x0)
+  TNamed(name,title)
 {
   // named constructor
 }
-//____________________________________________________________________
-AliCFFrame::AliCFFrame(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn, const Double_t *binLimitsIn) :  
-  TNamed(name,title),
-  fNVar(0),
-  fNDim(0),
-  fNVarBinLimits(0),
-  fNVarBins(0x0),
-  fIndex(0x0),
-  fProduct(0x0),
-  fOffset(0x0),
-  fVarBinLimits(0x0)
-{
-  //
-  // main constructor
-  //
-
-  //the number of variables on the grid
-  fNVar=nVarIn;
-
-  // the binning in each variable
-  fNVarBins= new Int_t[fNVar];
-
-  fIndex= new Int_t[fNVar];
-
-  Int_t ndimTot=1;
-  Int_t nbinTot=0;
-
-
-  //Calculate total number of elements and bins...
-
-  for(Int_t i=0;i<fNVar;i++){
-    fNVarBins[i]=nBinIn[i];
-    ndimTot*=nBinIn[i];
-    nbinTot+=(nBinIn[i]+1);
-  } 
-
-
-  //total number of elements
-
-  fNDim=ndimTot;
-
-  fOffset= new Int_t[fNVar];
-  fProduct= new Int_t[fNVar];
-
-  for(Int_t ivar=0;ivar<fNVar;ivar++){
-    Int_t offset=0;
-    for(Int_t i =0;i<ivar;i++)offset+=(fNVarBins[i]+1);      
-    fOffset[ivar]=offset;
-    Int_t prod=1;
-    for(Int_t i=0;i<ivar;i++)prod*=fNVarBins[i];
-    fProduct[ivar]=prod;
-  }
-
-  //The bin limits
-
-  fNVarBinLimits=nbinTot;
-  fVarBinLimits=new Double_t[fNVarBinLimits];
-  if(binLimitsIn){
-    for(Int_t i=0;i<fNVarBinLimits;i++){
-      fVarBinLimits[i] =binLimitsIn[i];
-    } 
-  }
-}
-//____________________________________________________________________
-AliCFFrame::AliCFFrame(const AliCFFrame& c) : 
-  TNamed(),
-  fNVar(0),
-  fNDim(0),
-  fNVarBinLimits(0),
-  fNVarBins(0x0),
-  fIndex(0x0),
-  fProduct(0x0),
-  fOffset(0x0),
-  fVarBinLimits(0x0)
-{
-  //
-  // copy constructor
-  //
-  ((AliCFFrame &)c).Copy(*this);
-}
-//____________________________________________________________________
-AliCFFrame::~AliCFFrame()
-{
-  //
-  // destructor
-  //
-  if(fNVarBins)delete [] fNVarBins;
-  if(fVarBinLimits)delete [] fVarBinLimits;
-  if(fIndex)delete [] fIndex;
-  if(fProduct)delete [] fProduct;
-  if(fOffset)delete [] fOffset;
-
-}
-//____________________________________________________________________
-AliCFFrame &AliCFFrame::operator=(const AliCFFrame &c)
-{
-  //
-  // assigment operator
-  //
-  if (this != &c)
-    ((AliCFFrame &) c).Copy(*this);
-  return *this;
-} 
-//____________________________________________________________________
-void AliCFFrame::SetBinLimits(Int_t ivar, Double_t *array)
-{
-  //
-  // setting the arrays containing the bin limits 
-  //
-  Int_t nbins=fNVarBins[ivar]+1;
-  for(Int_t i=0;i<nbins;i++){
-    fVarBinLimits[fOffset[ivar]+i] =array[i];
-  } 
-} 
-//____________________________________________________________________
-void AliCFFrame::GetBinLimits(Int_t ivar, Double_t *array) const
-{
-  //
-  // getting the arrays containing the bin limits 
-  //
-  Int_t nbins=fNVarBins[ivar]+1;
-  for(Int_t i=0;i<nbins;i++){
-    array[i]=fVarBinLimits[fOffset[ivar]+i];
-  } 
-} 
-//____________________________________________________________________
-Int_t AliCFFrame::GetBinIndex(Int_t *ibin) const
-{
-  //
-  // getting the element number on the grid for a given set of bin indeces 
-  //(here the numbering of bin indeces ranges from 0 to N-1)
-  //
-  Int_t ind=ibin[fNVar-1];
-  for(Int_t i=fNVar-1;i>0;i--){
-    ind=ibin[i-1]+ind*fNVarBins[i-1]; 
-  }
-  return ind;
-} 
-//____________________________________________________________________
-Int_t AliCFFrame::GetBinIndex(Int_t ivar, Int_t ind) const
-{
-  //
-  // getting the bin index on a given dim. ivar for a given element ind 
-  // on the grid
-  //(here the numbering of bin indeces ranges from 0 to N-1)
-  //
-  Int_t index=-1;
-  for(Int_t i=fNVar-1;i>=0;i--){
-    index=ind/fProduct[i];
-    fIndex[i]=index;
-    ind-=index*fProduct[i];
-  }
-  
-  index=fIndex[ivar];
-  return index;
-}
-//____________________________________________________________________
-void AliCFFrame::GetBinIndex(Int_t ind, Int_t *bins ) const
-{
-  //
-  // getting the set of bin indeces for a given element ind on the grid
-  // (here the numbering of bin indeces ranges from 0 to N-1)
-  //
-  Int_t index=-1;
-  for(Int_t i=fNVar-1;i>=0;i--){
-    index=ind/fProduct[i];
-    bins[i]=index;
-    ind-=index*fProduct[i];
-  }
-  return;
-}
-//____________________________________________________________________
-Double_t AliCFFrame::GetBinCenter(Int_t ivar, Int_t ibin) const
-{
-  //
-  // getting the bin center of a given bin ibin along variable ivar
-  // (here the numbering of bin indeces in input 
-  //  ranges from 1 to N, TH1/2/3 and THnSparse convention)
-  //
-  if(ibin>fNVarBins[ivar] || ibin==0){
-    AliWarning(Form("bin index out of range, number of bins in variable %i ranges from 1 to %i", ivar,fNVarBins[ivar]));
-    return -1;
-  } 
-  Double_t binMin=fVarBinLimits[fOffset[ivar]+ibin-1];
-  Double_t binMax=fVarBinLimits[fOffset[ivar]+ibin];
-  Double_t val=0.5*(binMin+binMax);
-  return val;
-}
-//____________________________________________________________________
-void AliCFFrame::GetBinCenters(Int_t *ibin, Double_t *binCenter) const
-{
-  //
-  // gives the centers of the N-dim bin identified by a set of bin indeces 
-  // invar
-  // (here the numbering of bin indeces in input 
-  //  ranges from 1 to N, TH1/2/3 and THnSparse convention)
-  //
-  for(Int_t i=0;i<fNVar;i++){
-    binCenter[i]=GetBinCenter(i,ibin[i]);
-  }
-} //____________________________________________________________________
-Double_t AliCFFrame::GetBinSize(Int_t ivar, Int_t ibin) const
-{
-  //
-  // getting the bin size on axis ivar of a given bin ibin 
-  // (here the numbering of bin indeces in input 
-  //  ranges from 1 to N, TH1/2/3 and THnSparse convention)
-  //
 
-  if(ibin>fNVarBins[ivar] || ibin==0){
-    AliWarning(Form("bin index out of range, number of bins in variable %i ranges from 1 to %i", ivar,fNVarBins[ivar]));
-    return -1;
-  } 
-
-  Double_t binMin=fVarBinLimits[fOffset[ivar]+ibin-1];
-  Double_t binMax=fVarBinLimits[fOffset[ivar]+ibin];
-  Double_t val=binMax-binMin;
-  return val;
-}
-//____________________________________________________________________
-void AliCFFrame::GetBinSizes(Int_t *ibin, Double_t *binSizes) const
-{
-  //
-  // gives the sizes of the N-dim bin identified by a set of bin indeces 
-  // ibin
-  // (here the numbering of bin indeces in input 
-  //  ranges from 1 to N, TH1/2/3 and THnSparse convention)
-  //
-  for(Int_t i=0;i<fNVar;i++){
-    binSizes[i]=GetBinSize(i,ibin[i]);
-  }
-} 
-
-//____________________________________________________________________
-void AliCFFrame::Copy(TObject& c) const
-{
-  //
-  // copy function
-  //
-  AliCFFrame& target = (AliCFFrame &) c;
-
-  target.fNVar=fNVar;
-  target.fNDim=fNDim;
-  target.fNVarBinLimits=fNVarBinLimits;
-  if (fNVarBins)
-    target.fNVarBins = fNVarBins;
-  if (fVarBinLimits)
-    target.fVarBinLimits = fVarBinLimits;
-  if (fProduct)
-    target.fProduct = fProduct;
-  if (fOffset)
-    target.fOffset = fOffset;  
-}
-//____________________________________________________________________
-void AliCFFrame::PrintBinLimits()
-{
-  //
-  // printing the array containing the bin limits 
-  //
-  for(Int_t i=0;i<fNVarBinLimits;i++){
-    AliInfo(Form("bin limit index %i is: %f",i, fVarBinLimits[i]));
-  } 
-} 
-//____________________________________________________________________
-void AliCFFrame::PrintNBins()
-{
-  //
-  // printing the array containing the # of bins  
-  //
-  for(Int_t i=0;i<fNVar;i++){
-    AliInfo(Form("bins in var %i are: %i",i, fNVarBins[i]));
-  } 
-} 
-//____________________________________________________________________
-void AliCFFrame::Save(const Char_t *outfile) const
-{
-  //
-  // Save the grid to a root file
-  //
-
-  const char *dirname = "./";
-  TString filename = outfile;
-  TFile *file=0x0;
-  if((gSystem->FindFile(dirname,filename))!=NULL){
-      file = new TFile( outfile,"UPDATE");
-  }
-  else{
-    file = new TFile( outfile,"RECREATE");
-  } 
-  file->cd();
-  //write the object to a file
-  this->Write(GetName(),TObject::kSingleKey);
-  file->Close();
-  delete file;
-}
index 597e153..5ce2f6e 100644 (file)
@@ -17,46 +17,29 @@ class AliCFFrame : public TNamed
  public:
   AliCFFrame();
   AliCFFrame(const Char_t* name,const Char_t* title);
-  AliCFFrame(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t* nBinIn, const Double_t  *binLimitsIn=0);
-  AliCFFrame(const AliCFFrame & c);
-  
-  virtual ~AliCFFrame();
-  AliCFFrame& operator=(const AliCFFrame& corr);
-  virtual void  PrintBinLimits();
-  virtual void  PrintNBins();
-  virtual void  SetBinLimits(Int_t ivar, Double_t * array);
-  virtual void  GetBinLimits(Int_t ivar, Double_t * array) const;
-  virtual Int_t GetBinIndex(Int_t *ibin) const;
-  virtual void  GetBinIndex(Int_t iel, Int_t *ibin) const;
-  virtual Int_t GetBinIndex(Int_t ivar, Int_t ind) const;
-  virtual Int_t GetNDim() const {return fNDim;};
-  virtual Int_t GetNVar() const {return fNVar;};
-  virtual Int_t GetNBins(Int_t ivar) const {return fNVarBins[ivar];};
-  virtual Int_t GetNBinLimits() const {return fNVarBinLimits;};
-  virtual Int_t   *GetNBins() const {return fNVarBins;};
-  virtual Double_t *GetBinLimits() const {return fVarBinLimits;};
-  virtual Double_t GetBinCenter(Int_t ivar,Int_t ibin) const;
-  virtual Double_t GetBinSize(Int_t ivar,Int_t ibin) const;
-  virtual void    GetBinCenters(Int_t *ibin, Double_t *binCenter) const;
-  virtual void    GetBinSizes(Int_t *ibin, Double_t *binSizes) const;
-
-  //basic operations
-
-  virtual void Copy(TObject& c) const;
-  virtual void Save(const Char_t *outfile) const;
-  
- protected:
-  Int_t    fNVar; //number of variables in the grid
-  Int_t    fNDim; //Overall number of elements in the grid
-  Int_t    fNVarBinLimits; //total number of bin limits
-  Int_t    *fNVarBins; //[fNVar] size of the grid in each dimension (binning)
-  Int_t    *fIndex;//[fNVar] current N-dim index on the grid
-  Int_t    *fProduct;//[fNVar] current N-dim index on the grid
-  Int_t    *fOffset;//[fNVar] current N-dim index on the grid
-  Double_t  *fVarBinLimits;//[fNVarBinLimits] array defining the binLimits
-
-  
-  ClassDef(AliCFFrame,2);
+  virtual ~AliCFFrame() {} ;
+  virtual void Copy(TObject& c) const {TNamed::Copy(c);}
+
+  virtual Int_t      GetNVar()                                                   const = 0 ; // number of variables
+  virtual void       PrintBinLimits()                                            const = 0 ; // prints the bin limits for each variable
+  virtual void       PrintNBins()                                                const = 0 ; // prints the number of bins for each variable
+  virtual void       SetBinLimits(Int_t ivar, const Double_t * array)                  = 0 ; // sets the bin limits specified in array
+  virtual void       GetBinLimits(Int_t ivar, Double_t * array)                  const = 0 ; // puts in array the bin limits for variable ivar
+  virtual Double_t * GetBinLimits(Int_t ivar)                                    const = 0 ; // returns an array of bin limits for variable ivar
+  virtual Long_t     GetNBinsTotal()                                             const = 0 ; // total number of bins 
+  virtual Int_t      GetNBins(Int_t ivar)                                        const = 0 ; // number of bins for variable ivar
+  virtual Int_t    * GetNBins()                                                  const = 0 ; // returns an array containing the bins for each variable
+  virtual Float_t    GetBinCenter(Int_t ivar,Int_t ibin)                         const = 0 ; // the center of bin number ibin for variable ivar
+  virtual Float_t    GetBinSize  (Int_t ivar,Int_t ibin)                         const = 0 ; // the   size of bin number ibin for variable ivar
+  //virtual void       GetBinCenters(const Int_t *ibin, Float_t *binCenter)        const = 0 ; // 
+  //virtual void       GetBinSizes  (const Int_t *ibin, Float_t *binSizes)         const = 0 ; //
+
+  // probably not needed anymore
+/*   virtual Int_t      GetBinIndex(const Int_t *ibin)                              const = 0 ; */
+/*   virtual void       GetBinIndex(Int_t iel, const Int_t *ibin)                   const = 0 ; */
+/*   virtual Int_t      GetBinIndex(Int_t ivar, Int_t ind)                          const = 0 ; */
+
+  ClassDef(AliCFFrame,3);
 };
     
 #endif
diff --git a/CORRFW/AliCFGrid.cxx b/CORRFW/AliCFGrid.cxx
deleted file mode 100644 (file)
index 700f5cd..0000000
+++ /dev/null
@@ -1,1112 +0,0 @@
-/* $Id$ */
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-//---------------------------------------------------------------------//
-//                                                                     //
-// AliCFGrid Class                                                     //
-// Class to accumulate data on an N-dimensional grid, to be used       //
-// as input to get corrections for Reconstruction & Trigger efficiency // 
-// The class uses a one-dimensional array of floats to store the grid  //     
-// --Author : S.Arcelli                                                //
-//   Still to be done:                                                 //
-// --Implement methods to merge cells                                  //
-// --Interpolate among bins in a range                                 // 
-// This implementation will be eventually replaced by AliCFGridSparse  //
-//---------------------------------------------------------------------//
-//
-//
-#include "AliLog.h"
-#include "AliCFGrid.h"
-#include "TMath.h"
-#include "TROOT.h"
-#include "TH1D.h"
-#include "TH2D.h"
-#include "TH3D.h"
-
-//____________________________________________________________________
-ClassImp(AliCFGrid)
-
-//____________________________________________________________________
-AliCFGrid::AliCFGrid() : 
-  AliCFVGrid(),
-  fNentriesTot(0),
-  fNunfl(0x0),
-  fNovfl(0x0),
-  fData(0x0),
-  fErr2(0x0)
-{
-  // default constructor
-}
-//____________________________________________________________________
-AliCFGrid::AliCFGrid(const Char_t* name, const Char_t* title) : 
-  AliCFVGrid(name,title),
-  fNentriesTot(0),
-  fNunfl(0x0),
-  fNovfl(0x0),
-  fData(0x0),
-  fErr2(0x0)
-{
-  // default constructor
-}
-
-//____________________________________________________________________
-AliCFGrid::AliCFGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn, const Double_t *binLimitsIn) :  
-  AliCFVGrid(name,title,nVarIn,nBinIn,binLimitsIn),
-  fNentriesTot(0),
-  fNunfl(0x0),
-  fNovfl(0x0),
-  fData(0x0),
-  fErr2(0x0)
-{
-  //
-  // main constructor
-  //
-  //The over/underflows
-  fNunfl=new Float_t[fNVar];
-  fNovfl= new Float_t[fNVar];
-
-
-  //Initialization
-  fNentriesTot =0;
-  for(Int_t j=0;j<fNVar;j++){
-    fNunfl[j] =0;
-    fNovfl[j] =0;
-  }
-
-
-  // the grid
-  fData = new Float_t[fNDim]; 
-
-  //Initialization
-  for(Int_t j=0;j<fNDim;j++){
-    fData[j] =0;
-  }
-}
-
-//____________________________________________________________________
-AliCFGrid::AliCFGrid(const AliCFGrid& c) : 
-  AliCFVGrid(c),
-  fNentriesTot(0),
-  fNunfl(0x0),
-  fNovfl(0x0),
-  fData(0x0),
-  fErr2(0x0)
-{
-  //
-  // copy constructor
-  //
-  ((AliCFGrid &)c).Copy(*this);
-}
-
-//____________________________________________________________________
-AliCFGrid::~AliCFGrid()
-{
-  //
-  // destructor
-  //
-  if(fNunfl)delete fNunfl;
-  if(fNovfl)delete fNovfl;
-  if(fData)delete fData;
-  if(fSumW2)delete fErr2;
-
-}
-//____________________________________________________________________
-AliCFGrid &AliCFGrid::operator=(const AliCFGrid &c)
-{
-  //
-  // assigment operator
-  //
-  if (this != &c)
-    ((AliCFGrid &) c).Copy(*this);
-  return *this;
-} 
-//____________________________________________________________________
-Float_t AliCFGrid::GetElement(Int_t bin) const
-{
-  //
-  // Returns grid element bin
-  //
-  if(bin>=fNDim){
-    AliInfo(Form(" element index outside the grid, return -1"));
-    return -1.;
-  }
-  return fData[bin];
-}
-//____________________________________________________________________
-Float_t AliCFGrid::GetElement(Int_t *bin) const
-{
- //
-  // Get the content in a bin corresponding to a set of bin indexes
-  //
-  //-1 is to move from TH/ThnSparse N-dim bin convention to one in AliCFFrame
-  for(Int_t i=0;i<fNVar; i++)fIndex[i]=bin[i]-1;
-  Int_t ind =GetBinIndex(fIndex);
-  return GetElement(ind);
-}  
-//____________________________________________________________________
-Float_t AliCFGrid::GetElement(Double_t *var) const
-{
-  //
-  // Get the content in a bin corresponding to a set of input variables
-  //
-  Int_t unfl=0;  
-  Int_t ovfl=0;  
-  for(Int_t i=0;i<fNVar;i++){
-    Int_t nbins=fNVarBins[i]+1;
-    Double_t *bins=new Double_t[nbins];
-    for(Int_t ibin =0;ibin<nbins;ibin++){
-     bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
-    }
-
-    fIndex[i] = TMath::BinarySearch(nbins,bins,var[i]);
-
-    //underflows
-
-    if(var[i] < bins[0]){
-      unfl=1;
-    }
-
-    //overflows
-
-    if(var[i] > bins[nbins-1]){
-      ovfl=1;
-    }
-    delete [] bins;
-  }
-
-
-  //move to the TH/THnSparse convention in N-dim bin numbering 
-  for(Int_t i=0;i<fNVar; i++)fIndex[i]+=1;
-
-  if(!(ovfl==1 || unfl==1)){
-    return GetElement(fIndex);
-  }
-  else{
-    AliInfo(Form(" input variables outside the grid, return -1"));
-    return -1.;
-  }
-} 
-//____________________________________________________________________
-Float_t AliCFGrid::GetElementError(Int_t iel) const
-{
-  //
-  // Return the error on grid element iel
-  //
-  if(iel>=fNDim){
-    AliInfo(Form(" element index outside the grid, return -1"));
-    return -1.;
-  }
-  if(fSumW2)return TMath::Sqrt(fErr2[iel]);
-  return TMath::Sqrt(fData[iel]);
-}
-//____________________________________________________________________
-Float_t AliCFGrid::GetElementError(Int_t *bin) const
-{
-  //
-  // Get the error in a bin corresponding to a set of bin indeces
-  //
-  //-1 is to move from TH/ThnSparse N-dim bin convention to one in AliCFFrame
-  for(Int_t i=0;i<fNVar; i++)fIndex[i]=bin[i]-1;
-  Int_t ind =GetBinIndex(fIndex);
-  return GetElementError(ind);
-
-}
-//____________________________________________________________________
-Float_t AliCFGrid::GetElementError(Double_t *var) const
-{
-  //
-  // Get the error in a bin corresponding to a set of input variables
-  //
-  Int_t unfl=0;  
-  Int_t ovfl=0;  
-  for(Int_t i=0;i<fNVar;i++){
-    Int_t nbins=fNVarBins[i]+1;
-    Double_t *bins=new Double_t[nbins];
-    for(Int_t ibin =0;ibin<nbins;ibin++){
-     bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
-    }
-
-    fIndex[i] = TMath::BinarySearch(nbins,bins,var[i]);
-    //underflows
-
-    if(var[i] < bins[0]){
-      unfl=1;
-    }
-
-    //overflows
-
-    if(var[i] > bins[nbins-1]){
-      ovfl=1;
-    }
-    delete [] bins;
-  }
-
-  //move to the TH/THnSparse convention in N-dim bin numbering 
-  for(Int_t i=0;i<fNVar; i++)fIndex[i]+=1;
-  if(!(ovfl==1 || unfl==1)){
-    return GetElementError(fIndex);
-  }
-  else{
-    AliInfo(Form(" input variables outside the grid, return -1"));
-    return -1.;
-  }
-} 
-//____________________________________________________________________
-void AliCFGrid::SetElement(Int_t iel, Float_t val)
-{
-  //
-  // Sets grid element iel to val
-  //
-  if(iel>=fNDim){
-    AliInfo(Form(" element index outside the grid, no value set"));
-  }else {
-    fData[iel]=val;
-  }
-}
-//____________________________________________________________________
-void AliCFGrid::SetElement(Int_t *bin, Float_t val)
-{
-  //
-  // Sets grid element of bin indeces bin to val
-  //
-  //-1 is to move from TH/ThnSparse N-dim bin convention to one in AliCFFrame
-  for(Int_t i=0;i<fNVar; i++)fIndex[i]=bin[i]-1;
-  Int_t ind =GetBinIndex(fIndex);
-  SetElement(ind,val);
-}
-//____________________________________________________________________
-void AliCFGrid::SetElement(Double_t *var, Float_t val) 
-{
-  //
-  // Set the content in a bin to value val corresponding to a set of input variables
-  //
-  Int_t unfl=0;  
-  Int_t ovfl=0;  
-  for(Int_t i=0;i<fNVar;i++){
-    Int_t nbins=fNVarBins[i]+1;
-    Double_t *bins=new Double_t[nbins];
-    for(Int_t ibin =0;ibin<nbins;ibin++){
-     bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
-    }
-
-    fIndex[i] = TMath::BinarySearch(nbins,bins,var[i]);
-    //underflows
-
-    if(var[i] < bins[0]){
-      unfl=1;
-    }
-
-    //overflows
-
-    if(var[i] > bins[nbins-1]){
-      ovfl=1;
-    }
-    delete [] bins;
-  }
-
-  //move to the TH/THnSparse convention in N-dim bin numbering 
-  for(Int_t i=0;i<fNVar; i++)fIndex[i]+=1;
-  if(!(ovfl==1 || unfl==1)){
-    SetElement(fIndex,val);
-  }
-  else{
-    AliInfo(Form(" input variables outside the grid, no value set"));
-  }
-} 
-//____________________________________________________________________
-void AliCFGrid::SetElementError(Int_t iel, Float_t val) 
-{
-  //
-  // Set squared error on grid element iel to val*val
-  //
-  if(iel>=fNDim){
-    AliInfo(Form(" element index outside the grid, no value set"));
-    return;
-  }
-  if(!fErr2)SumW2();
-  fErr2[iel]=val*val;   
-}
-//____________________________________________________________________
-void AliCFGrid::SetElementError(Int_t *bin, Float_t val) 
-{
-  //
-  // Set squared error to val on grid element of bin indeces bin
-  //
-  //-1 is to move from TH/ThnSparse N-dim bin convention to one in AliCFFrame
-  for(Int_t i=0;i<fNVar; i++)fIndex[i]=bin[i]-1;
-  Int_t ind =GetBinIndex(fIndex);
-  SetElementError(ind,val);
-}
-//____________________________________________________________________
-void AliCFGrid::SetElementError(Double_t *var, Float_t val)
-{
-  //
-  // Set squared error to val in a bin corresponding to a set of input variables
-  //
-  Int_t unfl=0;  
-  Int_t ovfl=0;  
-  for(Int_t i=0;i<fNVar;i++){
-    Int_t nbins=fNVarBins[i]+1;
-    Double_t *bins=new Double_t[nbins];
-    for(Int_t ibin =0;ibin<nbins;ibin++){
-     bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
-    }
-
-    fIndex[i] = TMath::BinarySearch(nbins,bins,var[i]);
-    //underflows
-
-    if(var[i] < bins[0]){
-      unfl=1;
-    }
-
-    //overflows
-
-    if(var[i] > bins[nbins-1]){
-      ovfl=1;
-    }
-    delete [] bins;
-  }
-
-  //move to the TH/THnSparse convention in N-dim bin numbering 
-  for(Int_t i=0;i<fNVar; i++)fIndex[i]+=1;
-
-  if(!(ovfl==1 || unfl==1)){
-    SetElementError(fIndex,val);
-  }
-  else{
-    AliInfo(Form(" input variables outside the grid, no value set"));
-  }
-} 
-//____________________________________________________________________
-void AliCFGrid::Fill(Double_t *var, Double_t weight)
-{
-
-  //
-  // Fill the grid,
-  // given a set of values of the input variable, 
-  // with weight (by default w=1)
-  //
-
-
-  Int_t isunfl=0;  
-  Int_t isovfl=0;  
-  Int_t *unfl=new Int_t[fNVar];  
-  Int_t *ovfl=new Int_t[fNVar];  
-
-  for(Int_t i=0;i<fNVar;i++){
-    unfl[i]=0;
-    ovfl[i]=0;
-  }
-
-  for(Int_t i=0;i<fNVar;i++){
-    Int_t nbins=fNVarBins[i]+1;
-    Double_t *bins=new Double_t[nbins];
-    for(Int_t ibin =0;ibin<nbins;ibin++){
-     bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
-    }
-
-    fIndex[i] = TMath::BinarySearch(nbins,bins,var[i]);
-    //underflows
-
-    if(var[i] < bins[0]){
-      unfl[i]=1;  
-      isunfl=1;
-    }
-
-    //overflows
-
-    if(var[i] > bins[nbins-1]){
-      ovfl[i]=1;  
-      isovfl=1;
-    }
-    delete [] bins;
-  }
-
-  //exclusive under/overflows
-
-  for(Int_t i=0;i<fNVar;i++){
-    Bool_t add=kTRUE;
-    for(Int_t j=0;j<fNVar;j++){
-      if(i==j)continue;
-      if(!(unfl[j]==0 && ovfl[j]==0))add=kFALSE;
-    }
-    if(add && unfl[i]==1)fNunfl[i]++;
-    if(add && ovfl[i]==1)fNovfl[i]++;
-  }
-
-  delete [] unfl;
-  delete [] ovfl;
-
-  // Total number of entries, overflows and underflows
-
-  fNentriesTot++;
-
-  //if not ovfl/unfl, fill the element  
-
-  if(!(isovfl==1 || isunfl==1)){
-    Int_t ind =GetBinIndex(fIndex);
-    fData[ind]+=weight;
-    if(fSumW2)fErr2[ind]+=(weight*weight);
-  }
-} 
-//____________________________________________________________________
-Float_t AliCFGrid::GetOverFlows( Int_t ivar) const {
-  //
-  // Get overflows in variable var 
-  //
-  return fNovfl[ivar];
-} 
-//____________________________________________________________________
-Float_t AliCFGrid::GetUnderFlows( Int_t ivar) const {
-  //
-  // Get overflows in variable var 
-  //
-  return fNunfl[ivar];
-} 
-//____________________________________________________________________
-Float_t AliCFGrid::GetEntries( ) const {
-  //
-  // Get total entries (in grid + over/underflows) 
-  //
-  return fNentriesTot;
-} 
-//___________________________________________________________________
-TH1D *AliCFGrid::Project(Int_t ivar) const
-{
-  //
-  // Make a 1D projection along variable ivar 
-
-
-  Int_t nbins =fNVarBins[ivar];
-  Float_t *bins = new Float_t[nbins+1];    
-  for (Int_t i=0;i<=fNVar;i++){
-  }
-  for(Int_t ibin =0;ibin<nbins+1;ibin++){
-    bins[ibin] = fVarBinLimits[ibin+fOffset[ivar]];
-  }
-
-  char pname[40];
-  sprintf(pname,"%s%s_%i",GetName(),"_proj1D_var", ivar);
-  char htitle[40];
-  sprintf(htitle,"%s%s_%i",GetName(),"_proj1D_var", ivar);
-
-  TH1D *proj1D=0;
-
-  //check if a projection with identical name exist
-  TObject *obj = gROOT->FindObject(pname);
-  if (obj && obj->InheritsFrom("TH1D")) {
-    proj1D = (TH1D*)obj;
-    proj1D->Reset();
-  }
-
-  if(!proj1D){
-    proj1D =new TH1D(pname,htitle, nbins, bins);
-  }  
-
-  delete [] bins;
-  Float_t sum=0;
-  Float_t *data= new Float_t[nbins];
-  Float_t *err= new Float_t[nbins];
-  
-  for(Int_t ibin=0;ibin<nbins;ibin++)data[ibin]=0;
-  for(Int_t ibin=0;ibin<nbins;ibin++)err[ibin]=0;
-  for(Int_t iel=0;iel<fNDim;iel++){
-      data[GetBinIndex(ivar,iel)]+=fData[iel];
-      if(fSumW2)err[GetBinIndex(ivar,iel)]+=fErr2[iel];
-  }
-
-  for(Int_t ibin =0;ibin<nbins;ibin++){
-    proj1D->SetBinContent(ibin+1,data[ibin]);
-    proj1D->SetBinError(ibin+1,TMath::Sqrt(data[ibin]));
-    if(fSumW2)proj1D->SetBinError(ibin+1,TMath::Sqrt(err[ibin]));
-    sum+=data[ibin];
-  }
-
-  delete [] data;
-  delete [] err;
-  proj1D->SetBinContent(nbins+1,GetOverFlows(ivar));
-  proj1D->SetBinContent(0,GetUnderFlows(ivar));
-  proj1D->SetEntries(fNentriesTot);
-  return proj1D;
-} 
-
-//___________________________________________________________________
-TH2D *AliCFGrid::Project(Int_t ivar1, Int_t ivar2) const
-{
-  //
-  // Make a 2D projection along variable ivar 
-
-  Int_t nbins1 =fNVarBins[ivar1];
-  Int_t nbins2 =fNVarBins[ivar2];
-
-  Float_t *bins1 = new Float_t[nbins1+1];         
-  Float_t *bins2 = new Float_t[nbins2+1];     
-
-  for(Int_t ibin =0;ibin<nbins1+1;ibin++){
-    bins1[ibin] = fVarBinLimits[ibin+fOffset[ivar1]];
-  }
-  for(Int_t ibin =0;ibin<nbins2+1;ibin++){
-    bins2[ibin] = fVarBinLimits[ibin+fOffset[ivar2]];
-  }
-
-  char pname[40];
-  sprintf(pname,"%s%s_%i_%i",GetName(),"_proj2D_var",ivar1,ivar2);
-  char htitle[40];
-  sprintf(htitle,"%s%s_%i_%i",GetName(),"_proj2D_var",ivar1,ivar2);
-
-  TH2D *proj2D=0;
-
-  //check if a projection with identical name exist
-  TObject *obj = gROOT->FindObject(pname);
-  if (obj && obj->InheritsFrom("TH2D")) {
-    proj2D = (TH2D*)obj;
-    proj2D->Reset();
-  }
-
-  if(!proj2D){
-    proj2D =new TH2D(pname,htitle, nbins1, bins1,nbins2,bins2);
-  }  
-
-  delete [] bins1;
-  delete [] bins2;
-
-
-  Float_t sum=0;
-  Float_t **data=new Float_t*[nbins1];
-  Float_t *data2=new Float_t[nbins1*nbins2];
-  Float_t **err=new Float_t*[nbins1];
-  Float_t *err2=new Float_t[nbins1*nbins2];
-  for(Int_t i=0;i<nbins1;i++)data[i] = data2+i*nbins2;
-  for(Int_t i=0;i<nbins1;i++)err[i] = err2+i*nbins2;
-
-  for(Int_t ibin1 =0;ibin1<nbins1;ibin1++){
-    for(Int_t ibin2 =0;ibin2<nbins2;ibin2++){
-      data[ibin1][ibin2]=0;
-      err[ibin1][ibin2]=0;
-    }
-  }
-
-  for(Int_t iel=0;iel<fNDim;iel++){
-    data[GetBinIndex(ivar1,iel)][GetBinIndex(ivar2,iel)]+=fData[iel];
-    if(fSumW2)err[GetBinIndex(ivar1,iel)][GetBinIndex(ivar2,iel)]+=fErr2[iel];
-  }
-
-  for(Int_t ibin1 =0;ibin1<nbins1;ibin1++){
-    for(Int_t ibin2 =0;ibin2<nbins2;ibin2++){
-      proj2D->SetBinContent(ibin1+1,ibin2+1,data[ibin1][ibin2]);
-      proj2D->SetBinError(ibin1+1,ibin2+1,TMath::Sqrt(data[ibin1][ibin2]));
-      if(fSumW2)proj2D->SetBinError(ibin1+1,ibin2+1,TMath::Sqrt(err[ibin1][ibin2]));
-      sum+=data[ibin1][ibin2];
-    }
-
-  } 
-  delete data;
-  delete data2;
-  delete err;
-  delete err2;
-  proj2D->SetBinContent(0,nbins2/2,GetUnderFlows(ivar1));
-  proj2D->SetBinContent(nbins1+1,nbins2/2,GetOverFlows(ivar1));
-  proj2D->SetBinContent(nbins1/2,0,GetUnderFlows(ivar2));
-  proj2D->SetBinContent(nbins1/2,nbins2+1,GetOverFlows(ivar2));
-  proj2D->SetEntries(fNentriesTot);
-  return proj2D;
-} 
-//___________________________________________________________________
-TH3D *AliCFGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
-{
-  //
-  // Make a 3D projection along variable ivar 
-
-  Int_t nbins1 =fNVarBins[ivar1];
-  Int_t nbins2 =fNVarBins[ivar2];
-  Int_t nbins3 =fNVarBins[ivar3];
-
-  Float_t *bins1 = new Float_t[nbins1+1];         
-  Float_t *bins2 = new Float_t[nbins2+1];     
-  Float_t *bins3 = new Float_t[nbins3+1];     
-
-  for(Int_t ibin =0;ibin<nbins1+1;ibin++){
-    bins1[ibin] = fVarBinLimits[ibin+fOffset[ivar1]];
-  }
-  for(Int_t ibin =0;ibin<nbins2+1;ibin++){
-    bins2[ibin] = fVarBinLimits[ibin+fOffset[ivar2]];
-  }
-  for(Int_t ibin =0;ibin<nbins3+1;ibin++){
-    bins3[ibin] = fVarBinLimits[ibin+fOffset[ivar3]];
-  }
-
-  char pname[40];
-  sprintf(pname,"%s%s_%i_%i_%i",GetName(),"_proj3D_var",ivar1,ivar2,ivar3);
-  char htitle[40];
-  sprintf(htitle,"%s%s_%i_%i_%i",GetName(),"_proj3D_var",ivar1,ivar2,ivar3);
-
-  TH3D *proj3D=0;
-
-  //check if a projection with identical name exist
-  TObject *obj = gROOT->FindObject(pname);
-  if (obj && obj->InheritsFrom("TH3D")) {
-    proj3D = (TH3D*)obj;
-    proj3D->Reset();
-  }
-
-  if(!proj3D){
-    proj3D =new TH3D(pname,htitle, nbins1,bins1,nbins2,bins2,nbins3,bins3);
-  }  
-
-  delete [] bins1;
-  delete [] bins2;
-  delete [] bins3;
-
-
-  Float_t sum=0;
-  Float_t ***data=new Float_t**[nbins1];
-  Float_t **data2=new Float_t*[nbins1*nbins2];
-  Float_t *data3=new Float_t[nbins1*nbins2*nbins3];
-  Float_t ***err=new Float_t**[nbins1];
-  Float_t **err2=new Float_t*[nbins1*nbins2];
-  Float_t *err3=new Float_t[nbins1*nbins2*nbins3];
-  for(Int_t i=0;i<nbins1;i++)data[i] = data2+i*nbins2;
-  for(Int_t i=0;i<nbins1;i++)err[i] = err2+i*nbins2;
-  for(Int_t i=0;i<nbins1;i++){
-    for(Int_t j=0;j<nbins2;j++){
-      data[i][j] = data3+i*nbins2*nbins3+j*nbins3;
-      err[i][j] = err3+i*nbins2*nbins3+j*nbins3;
-    }
-  }
-  for(Int_t ibin1 =0;ibin1<nbins1;ibin1++){
-    for(Int_t ibin2 =0;ibin2<nbins2;ibin2++){
-      for(Int_t ibin3 =0;ibin3<nbins3;ibin3++){
-       data[ibin1][ibin2][ibin3]=0;
-       err[ibin1][ibin2][ibin3]=0;
-      }
-    }
-  }
-  
-  for(Int_t iel=0;iel<fNDim;iel++){
-    data[GetBinIndex(ivar1,iel)][GetBinIndex(ivar2,iel)][GetBinIndex(ivar3,iel)]+=fData[iel];
-    if(fSumW2)err[GetBinIndex(ivar1,iel)][GetBinIndex(ivar2,iel)][GetBinIndex(ivar3,iel)]+=fErr2[iel];
-  }
-
-  for(Int_t ibin1 =0;ibin1<nbins1;ibin1++){
-    for(Int_t ibin2 =0;ibin2<nbins2;ibin2++){
-      for(Int_t ibin3 =0;ibin3<nbins3;ibin3++){
-       proj3D->SetBinContent(ibin1+1,ibin2+1,ibin3+1,data[ibin1][ibin2][ibin3]);
-       proj3D->SetBinError(ibin1+1,ibin2+1,ibin3+1,TMath::Sqrt(data[ibin1][ibin2][ibin3]));
-       if(fSumW2)proj3D->SetBinError(ibin1+1,ibin2+1,ibin3+1,TMath::Sqrt(err[ibin1][ibin2][ibin3]));
-       sum+=data[ibin1][ibin2][ibin3];
-      }
-    }
-  } 
-
-  delete data;
-  delete data2;
-  delete data3;
-  delete err;
-  delete err2;
-  delete err3;
-
-  proj3D->SetEntries(fNentriesTot);
-  return proj3D;
-} 
-
-//___________________________________________________________________
-TH1D *AliCFGrid::Slice(Int_t ivar, Double_t *varMin, Double_t* varMax) const
-{
-  //
-  // Make a slice along variable ivar in range [varMin,varMax]
-
-
-  Int_t nbins =fNVarBins[ivar];
-  Float_t *bins = new Float_t[nbins+1];    
-  for (Int_t i=0;i<=fNVar;i++){
-  }
-  for(Int_t ibin =0;ibin<nbins+1;ibin++){
-    bins[ibin] = fVarBinLimits[ibin+fOffset[ivar]];
-  }
-
-  char pname[40];
-  sprintf(pname,"%s%s_%i",GetName(),"_proj1D_var", ivar);
-  char htitle[40];
-  sprintf(htitle,"%s%s_%i",GetName(),"_proj1D_var", ivar);
-
-  TH1D *proj1D=0;
-
-  //check if a projection with identical name exist
-  TObject *obj = gROOT->FindObject(pname);
-  if (obj && obj->InheritsFrom("TH1D")) {
-    proj1D = (TH1D*)obj;
-    proj1D->Reset();
-  }
-
-  if(!proj1D){
-    proj1D =new TH1D(pname,htitle, nbins, bins);
-  }  
-
-  delete [] bins;
-
-
-  Int_t *indexMin=new Int_t[fNVar];
-  Int_t *indexMax=new Int_t[fNVar];
-
-
-  //Find out the min and max bins
-
-  for(Int_t i=0;i<fNVar;i++){
-    Double_t xmin=varMin[i]; // the min values  
-    Double_t xmax=varMax[i]; // the max values  
-    Int_t nBins=fNVarBins[i]+1;
-    Double_t *Bins=new Double_t[nBins];
-    for(Int_t ibin =0;ibin<nBins;ibin++){
-     Bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
-    }
-    indexMin[i] = TMath::BinarySearch(nBins,Bins,xmin);
-    indexMax[i] = TMath::BinarySearch(nBins,Bins,xmax);
-    delete [] Bins;
-  }
-
-  Float_t sum=0;
-  Float_t *data= new Float_t[nbins];
-  for(Int_t ibin=0;ibin<nbins;ibin++)data[ibin]=0;
-
-  Int_t *index= new Int_t[fNVar];
-  Int_t ielmin=GetBinIndex(indexMin);
-  Int_t ielmax=GetBinIndex(indexMax);
-
-
-  for(Int_t iel=ielmin;iel<=ielmax;iel++){
-    GetBinIndex(iel,index);
-    Bool_t isIn=kTRUE;
-    for (Int_t j=0;j<fNVar;j++){
-      if(!(index[j]>=indexMin[j] && index[j]<=indexMax[j]))isIn=kFALSE;   
-      break;
-    }
-    if(isIn)data[GetBinIndex(ivar,iel)]+=fData[iel];
-  }
-
-  delete [] index;
-  delete [] indexMin;
-  delete [] indexMax;
-
-
-  for(Int_t ibin =0;ibin<nbins;ibin++){
-    proj1D->SetBinContent(ibin+1,data[ibin]);
-    proj1D->SetBinError(ibin+1,TMath::Sqrt(data[ibin]));
-    sum+=data[ibin];
-  }
-
-  delete [] data;
-
-  proj1D->SetEntries(sum);
-  return proj1D;
-} 
-
-
-//____________________________________________________________________
-void AliCFGrid::Add(const AliCFVGrid* aGrid, Double_t c)
-{
-  //
-  //add aGrid to the current one
-  //
-
-  if(aGrid->GetNVar()!=fNVar){
-    AliInfo("Different number of variables, cannot add the grids");
-    return;
-  } 
-  if(aGrid->GetNDim()!=fNDim){
-    AliInfo("Different number of dimensions, cannot add the grids!");
-    return;
-  } 
-  
-  if(!fSumW2  && aGrid->GetSumW2())SumW2();
-
-  for(Int_t iel=0;iel<fNDim;iel++){
-    fData[iel]+=(c*aGrid->GetElement(iel));
-    if(fSumW2){
-      Float_t err=aGrid->GetElementError(iel);  
-      fErr2[iel]+=c*c*err*err;
-    }
-  }
-
-  //Add entries, overflows and underflows
-
-  fNentriesTot+= c*aGrid->GetEntries();
-  for(Int_t j=0;j<fNVar;j++){
-    fNunfl[j]+= c*aGrid->GetUnderFlows(j);
-    fNovfl[j]+= c*aGrid->GetOverFlows(j);
-  }
-}
-//____________________________________________________________________
-void AliCFGrid::Add(const AliCFVGrid* aGrid1, const AliCFVGrid* aGrid2, Double_t c1,Double_t c2)
-{
-  //
-  //add aGrid1 and aGrid2
-  //
-
-  if(fNVar!=aGrid1->GetNVar()|| fNVar!=aGrid2->GetNVar()){
-    AliInfo("Different number of variables, cannot add the grids");
-    return;
-  } 
-  if(fNDim!=aGrid1->GetNDim()|| fNDim!=aGrid2->GetNDim()){
-    AliInfo("Different number of dimensions, cannot add the grids!");
-    return;
-  } 
-  
-  if(!fSumW2  && (aGrid1->GetSumW2() || aGrid2->GetSumW2()))SumW2();
-
-  Float_t cont1,cont2,err1,err2;  
-
-  for(Int_t iel=0;iel<fNDim;iel++){
-    cont1=aGrid1->GetElement(iel);
-    cont2=aGrid2->GetElement(iel);
-    SetElement(iel,c1*cont1+c2*cont2);
-    if(fSumW2){
-      err1=aGrid1->GetElementError(iel);
-      err2=aGrid2->GetElementError(iel);
-      SetElementError(iel,TMath::Sqrt(c1*c1*err1*err1+c2*c2*err2*err2));
-    }
-  }
-
-  //Add entries, overflows and underflows
-
-  fNentriesTot= c1*aGrid1->GetEntries()+c2*aGrid2->GetEntries();
-  for(Int_t j=0;j<fNVar;j++){
-    fNunfl[j]= c1*aGrid1->GetUnderFlows(j)+c2*aGrid2->GetUnderFlows(j);
-    fNovfl[j]= c1*aGrid1->GetOverFlows(j)+c2*aGrid2->GetOverFlows(j);
-  }
-}
-//____________________________________________________________________
-void AliCFGrid::Multiply(const AliCFVGrid* aGrid, Double_t c)
-{
-  //
-  //multiply grid aGrid by the current one
-  //
-
-  if(aGrid->GetNVar()!=fNVar){
-    AliInfo("Different number of variables, cannot multiply the grids");
-    return;
-  } 
-  if(aGrid->GetNDim()!=fNDim){
-    AliInfo("Different number of dimensions, cannot multiply the grids!");
-    return;
-  } 
-  
-  if(!fSumW2  && aGrid->GetSumW2())SumW2();
-  
-  Float_t cont1,cont2,err1,err2;  
-
-  for(Int_t iel=0;iel<fNDim;iel++){
-    cont1=GetElement(iel);  
-    cont2=c*aGrid->GetElement(iel);  
-    SetElement(iel,cont1*cont2);
-    if(fSumW2){
-      err1=GetElementError(iel);  
-      err2=aGrid->GetElementError(iel);  
-      SetElementError(iel,TMath::Sqrt(c*c*(cont2*cont2*err1*err1+cont1*cont1*err2*err2)));
-    }
-  }
-
-  //Set entries to the number of bins, preserve original overflows and underflows
-
-  fNentriesTot=fNDim;
-  for(Int_t j=0;j<fNVar;j++){
-    fNunfl[j]= GetUnderFlows(j);
-    fNovfl[j]= GetOverFlows(j);
-  }
-}
-//____________________________________________________________________
-void AliCFGrid::Multiply(const AliCFVGrid* aGrid1, const AliCFVGrid* aGrid2, Double_t c1, Double_t c2)
-{
-  //
-  //multiply grids aGrid1 and aGrid2
-  //
-
-  if(fNVar!=aGrid1->GetNVar()|| fNVar!=aGrid2->GetNVar()){
-    AliInfo("Different number of variables, cannot multiply the grids");
-    return;
-  } 
-  if(fNDim!=aGrid1->GetNDim()|| fNDim!=aGrid2->GetNDim()){
-    AliInfo("Different number of dimensions, cannot multiply the grids!");
-    return;
-  } 
-  
-  if(!fSumW2  && (aGrid1->GetSumW2() || aGrid2->GetSumW2()))SumW2();
-
-  Float_t cont1,cont2,err1,err2;  
-  for(Int_t iel=0;iel<fNDim;iel++){
-    cont1=c1*aGrid1->GetElement(iel);  
-    cont2=c2*aGrid2->GetElement(iel);  
-    SetElement(iel,cont1*cont2);
-    if(fSumW2){
-      err1=aGrid1->GetElementError(iel);  
-      err2=aGrid2->GetElementError(iel);  
-      SetElementError(iel,TMath::Sqrt(c1*c1*c2*c2*(cont2*cont2*err1*err1+cont1*cont1*err2*err2)));
-    }
-  }
-
-  //Set entries to the number of bins, preserve original overflows and underflows
-
-  fNentriesTot=fNDim;
-  for(Int_t j=0;j<fNVar;j++){
-    fNunfl[j]= GetUnderFlows(j);
-    fNovfl[j]= GetOverFlows(j);
-  }
-}
-//____________________________________________________________________
-void AliCFGrid::Divide(const AliCFVGrid* aGrid, Double_t c)
-{
-  //
-  //divide current grid by grid aGrid
-  //
-
-  if(aGrid->GetNVar()!=fNVar){
-    AliInfo("Different number of variables, cannot divide the grids");
-    return;
-  } 
-  if(aGrid->GetNDim()!=fNDim){
-    AliInfo("Different number of dimensions, cannot divide the grids!");
-    return;
-  } 
- if(!c){AliInfo(Form("c is %f, cannot divide!",c)); return;} 
-  
-  if(!fSumW2  && aGrid->GetSumW2())SumW2();
-
-  Float_t cont1,cont2,err1,err2,den;
-  for(Int_t iel=0;iel<fNDim;iel++){
-    cont1=GetElement(iel);  
-    cont2=aGrid->GetElement(iel);
-    if(cont2)SetElement(iel,cont1/(c*cont2));
-    else SetElement(iel,0);
-    if(fSumW2){
-      err1=GetElementError(iel);  
-      err2=aGrid->GetElementError(iel);  
-      if(!cont2){SetElementError(iel,0.); continue;}
-      den=cont2*cont2*cont2*c*c;
-      SetElementError(iel,TMath::Sqrt((cont2*cont2*err1*err1+cont1*cont1*err2*err2)/den));
-    }
-  }
-  
-  //Set entries to the number of bins, preserve original overflows and underflows
-
-  fNentriesTot=fNDim;
-  for(Int_t j=0;j<fNVar;j++){
-    fNunfl[j]= GetUnderFlows(j);
-    fNovfl[j]= GetOverFlows(j);
-  }
-}
-//____________________________________________________________________
-void AliCFGrid::Divide(const AliCFVGrid* aGrid1, const AliCFVGrid* aGrid2, Double_t c1,Double_t c2, Option_t *option)
-{
-  //
-  //divide grids aGrid1,aGrid2
-  //
-
-  TString opt = option;
-  opt.ToUpper();
-
-  if(fNVar!=aGrid1->GetNVar()|| fNVar!=aGrid2->GetNVar()){
-    AliInfo("Different number of variables, cannot divide the grids");
-    return;
-  }
-  if(fNDim!=aGrid1->GetNDim()|| fNDim!=aGrid2->GetNDim()){
-    AliInfo("Different number of dimensions, cannot divide the grids!");
-    return;
-  }
-  if(!c2){AliInfo(Form("c2 is %f, cannot divide!",c2)); return;} 
-  
-  if(!fSumW2  && (aGrid1->GetSumW2() || aGrid2->GetSumW2()))SumW2();
-
-  Float_t cont1,cont2,err1,err2,r,den;
-  for(Int_t iel=0;iel<fNDim;iel++){
-    cont1=aGrid1->GetElement(iel);  
-    cont2=aGrid2->GetElement(iel);  
-    if(cont2)SetElement(iel,c1*cont1/(c2*cont2));
-    else SetElement(iel,0);
-     if(fSumW2){
-      err1=aGrid1->GetElementError(iel);  
-      err2=aGrid2->GetElementError(iel);  
-      if(!cont2){SetElementError(iel,0.); continue;}
-      if (opt.Contains("B")){
-       if(cont1!=cont2){
-         r=cont1/cont2;            
-         SetElementError(iel,TMath::Sqrt(TMath::Abs(((1.-2.*r)*err1*err1+r*r*err2*err2)/(cont2*cont2))));
-       }else{
-         SetElementError(iel,0.);
-       }
-      }else{
-        den=cont2*cont2*cont2*cont2*c2*c2;
-       SetElementError(iel,TMath::Sqrt(c1*c1*(cont2*cont2*err1*err1+cont1*cont1*err2*err2)/den));
-      }
-    }
-  }
-
-  //Set entries to the number of bins, preserve original overflows and underflows
-
-  fNentriesTot=fNDim;
-  for(Int_t j=0;j<fNVar;j++){
-    fNunfl[j]= GetUnderFlows(j);
-    fNovfl[j]= GetOverFlows(j);
-  }
-}
-//____________________________________________________________________
-void AliCFGrid::Rebin(const Int_t* group)
-{
-  //
-  // Not yet implemented
-  //
-  for(Int_t i=0;i<fNVar;i++){
-    if(group[i]!=1)AliInfo(Form(" merging bins along dimension %i in groups of %i bins", i,group[i]));
-  }
-  AliInfo(Form("This method was so far not implemented for AliCFGrid, but it is available for AliCFGridSparse"));
-
-}
-//____________________________________________________________________
-void AliCFGrid::SumW2()
-{
-  //
-  //set calculation of the squared sum of the weighted entries
-  //
-  if(!fSumW2){
-    fErr2=new Float_t [fNDim];
-    //init....
-    for(Int_t iel=0;iel<fNDim;iel++){
-      fErr2[iel]=fData[iel];
-    }
-  }
-
-  fSumW2=kTRUE;
-}
-//____________________________________________________________________
-void AliCFGrid::Copy(TObject& c) const
-{
-  //
-  // copy function
-  //
-  AliCFGrid& target = (AliCFGrid &) c;
-
-  target.fNentriesTot = fNentriesTot;
-  if (fNunfl)
-    target.fNunfl = fNunfl;
-  if (fNovfl)
-    target.fNovfl = fNovfl;
-  if (fData)
-    target.fData = fData;
-  if (fErr2)
-    target.fErr2 = fErr2;
-  
-}
diff --git a/CORRFW/AliCFGrid.h b/CORRFW/AliCFGrid.h
deleted file mode 100644 (file)
index 1906a63..0000000
+++ /dev/null
@@ -1,89 +0,0 @@
-#ifndef ALICFGRID_H
-#define ALICFGRID_H
-
-//--------------------------------------------------------------------//
-//                                                                    //
-// AliCFGrid.cxx Class                                                //
-// Class to handle N-dim maps for the correction Framework            // 
-// The class uses a une-dimensional array of floats to store the grid //     
-//                                                                    //
-//--------------------------------------------------------------------//
-
-#include "AliCFVGrid.h"
-#include "AliLog.h"
-
-class TH1D;
-class TH2D;
-class TH3D;
-
-class AliCFGrid : public AliCFVGrid
-{
- public:
-  AliCFGrid();
-  AliCFGrid(const Char_t* name,const Char_t* title);
-  AliCFGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t* nBinIn, const Double_t  *binLimitsIn=0);
-  AliCFGrid(const AliCFGrid & c);
-  
-  virtual ~AliCFGrid();
-  AliCFGrid& operator=(const AliCFGrid& corr);
-
-  virtual void  Fill(Double_t *var, Double_t weight=1.);
-
-  virtual Float_t GetOverFlows(Int_t var) const;
-  virtual Float_t GetUnderFlows(Int_t var)const ;
-  virtual Float_t GetEntries()const ;
-
-  virtual Float_t GetElement(Int_t iel)const; 
-  virtual Float_t GetElement(Int_t *bin)const; 
-  virtual Float_t GetElement(Double_t *var)const; 
-  virtual Float_t GetElementError(Int_t iel)const; 
-  virtual Float_t GetElementError(Int_t *bin)const; 
-  virtual Float_t GetElementError(Double_t *var)const; 
-  virtual void SetElement(Int_t iel, Float_t val); 
-  virtual void SetElement(Int_t *bin, Float_t val); 
-  virtual void SetElement(Double_t *var, Float_t val); 
-  virtual void SetElementError(Int_t iel, Float_t val); 
-  virtual void SetElementError(Int_t *bin, Float_t val); 
-  virtual void SetElementError(Double_t *var, Float_t val); 
-
-  virtual TH1D*      Project( Int_t ivar) const;
-  virtual TH2D*      Project( Int_t ivar1, Int_t ivar2) const;
-  virtual TH3D*      Project( Int_t ivar1, Int_t ivar2,Int_t ivar3) const;
-  virtual AliCFGrid* Project( Int_t /*nVars*/, Int_t* /*vars*/, Double_t* /*varMin*/, Double_t* /*varMax*/) const
-  {AliWarning("not implemented"); return 0x0;}
-  virtual TH1D* Slice( Int_t ivar, Double_t *varMin, Double_t *varMax) const;
-  virtual TH2D* Slice( Int_t /*ivar1*/, Int_t /*ivar2*/, Double_t */*varMin*/, Double_t */*varMax*/) const 
-  {AliWarning("not implemented"); return 0x0;}
-  virtual TH3D* Slice( Int_t /*ivar1*/, Int_t /*ivar2*/, Int_t /*ivar3*/, Double_t */*varMin*/, Double_t */*varMax*/) const 
-  {AliWarning("not implemented"); return 0x0;}
-
-  virtual void UseAxisRange(Bool_t /*b*/) const {AliWarning("Not implemented because this class is obsolete");}
-
-  //basic operations
-
-  virtual void SumW2();
-  virtual void Copy(TObject& c) const;
-  virtual void Add(const AliCFVGrid* aGrid, Double_t c=1.);
-  virtual void Add(const AliCFVGrid* aGrid1 ,const AliCFVGrid* aGrid2, Double_t c1=1.,Double_t c2=1.);
-  virtual void Multiply(const AliCFVGrid* aGrid, Double_t c=1.);
-  virtual void Multiply(const AliCFVGrid* aGrid1,const AliCFVGrid* aGrid2, Double_t c1=1.,Double_t c2=1.);
-  virtual void Divide(const AliCFVGrid* aGrid, Double_t c=1.);
-  virtual void Divide(const AliCFVGrid* aGrid1, const AliCFVGrid* aGrid2, Double_t c1=1., Double_t c2=1.,Option_t *option=0);
-
-  void Rebin(const Int_t* group);
-
-  
- protected:
-
-  Float_t  fNentriesTot;//Total number of entries 
-  Float_t  *fNunfl;//[fNVar] underflows in each dimension
-  Float_t  *fNovfl;//[fNVar] overflows in each dimension
-  Float_t  *fData;//[fNDim] The data Container
-  Float_t  *fErr2;//[fNDim] The squared weights Container (only with SumW2)
-
-  
-  ClassDef(AliCFGrid,4);
-};
-    
-#endif
-
index 078d63c..12eed5e 100755 (executable)
@@ -39,89 +39,75 @@ ClassImp(AliCFGridSparse)
 
 //____________________________________________________________________
 AliCFGridSparse::AliCFGridSparse() : 
-  AliCFVGrid(),
+  AliCFFrame(),
+  fSumW2(kFALSE),
   fData(0x0)
 {
   // default constructor
 }
 //____________________________________________________________________
 AliCFGridSparse::AliCFGridSparse(const Char_t* name, const Char_t* title) : 
-  AliCFVGrid(name,title),
+  AliCFFrame(name,title),
+  fSumW2(kFALSE),
   fData(0x0)
 {
   // default constructor
 }
 //____________________________________________________________________
-AliCFGridSparse::AliCFGridSparse(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn, const Double_t *binLimitsIn) :  
-  AliCFVGrid(name,title,nVarIn,nBinIn,binLimitsIn),
+AliCFGridSparse::AliCFGridSparse(const Char_t* name, const Char_t* title, Int_t nVarIn, const Int_t * nBinIn) :  
+  AliCFFrame(name,title),
+  fSumW2(kFALSE),
   fData(0x0)
 {
   //
   // main constructor
   //
 
-  fData=new THnSparseF(name,title,fNVar,fNVarBins);
-  
-  if(binLimitsIn){
-    for(Int_t ivar=0;ivar<fNVar;ivar++){    
-      Int_t nbins=fNVarBins[ivar]+1;
-      Double_t *array= new Double_t[nbins];
-      for(Int_t i=0;i<nbins;i++){
-       array[i]=fVarBinLimits[fOffset[ivar]+i];
-      } 
-      fData->SetBinEdges(ivar, array);
-      delete array;
-    }
-  }
+  fData = new THnSparseF(name,title,nVarIn,nBinIn);
 }
+
 //____________________________________________________________________
-AliCFGridSparse::AliCFGridSparse(const AliCFGridSparse& c) : 
-  AliCFVGrid(c),
-  fData(c.fData)
+AliCFGridSparse::~AliCFGridSparse()
 {
   //
-  // copy constructor
+  // destructor
   //
-  ((AliCFGridSparse &)c).Copy(*this);
+  if (fData) delete fData;
 }
 
 //____________________________________________________________________
-AliCFGridSparse::~AliCFGridSparse()
+AliCFGridSparse::AliCFGridSparse(const AliCFGridSparse& c) :
+  AliCFFrame(c),
+  fSumW2(kFALSE),
+  fData(0x0)
 {
   //
-  // destructor
+  // copy constructor
   //
-  if(fData) delete fData;
+  ((AliCFGridSparse &)c).Copy(*this);
 }
 
 //____________________________________________________________________
-AliCFGridSparse &AliCFGridSparse::operator=(const AliCFGridSparse &c)
+AliCFGridSparse& AliCFGridSparse::operator=(const AliCFGridSparse &c)
 {
   //
   // assigment operator
   //
-  if (this != &c)
-    ((AliCFGridSparse &) c).Copy(*this);
+  if (this != &c) c.Copy(*this);
   return *this;
 } 
 
 //____________________________________________________________________
-void AliCFGridSparse::SetBinLimits(Int_t ivar, Double_t *array)
+void AliCFGridSparse::SetBinLimits(Int_t ivar, const Double_t *array)
 {
   //
   // setting the arrays containing the bin limits 
   //
   fData->SetBinEdges(ivar, array);
-  //then fill the appropriate array in ALICFFrame, to be able to use 
-  //the getter, in case....
-  Int_t nbins=fNVarBins[ivar]+1;
-  for(Int_t i=0;i<nbins;i++){
-    fVarBinLimits[fOffset[ivar]+i] =array[i];
-  } 
 } 
 
 //____________________________________________________________________
-void AliCFGridSparse::Fill(Double_t *var, Double_t weight)
+void AliCFGridSparse::Fill(const Double_t *var, Double_t weight)
 {
   //
   // Fill the grid,
@@ -139,6 +125,8 @@ TH1D *AliCFGridSparse::Project(Int_t ivar) const
   //
 
   TH1D *hist=fData->Projection(ivar);
+  hist->SetXTitle(GetVarTitle(ivar));
+  hist->SetTitle(Form("%s: projection on %s",GetTitle(),GetVarTitle(ivar)));
   return hist;
 }
 //___________________________________________________________________
@@ -149,8 +137,10 @@ TH2D *AliCFGridSparse::Project(Int_t ivar1, Int_t ivar2) const
   //
 
   TH2D *hist=fData->Projection(ivar2,ivar1); //notice inverted axis (THnSparse uses TH3 2d-projection convention...)
+  hist->SetXTitle(GetVarTitle(ivar1));
+  hist->SetYTitle(GetVarTitle(ivar2));
+  hist->SetTitle(Form("%s: projection on %s-%s",GetTitle(),GetVarTitle(ivar1),GetVarTitle(ivar2)));
   return hist;
-
 }
 //___________________________________________________________________
 TH3D *AliCFGridSparse::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
@@ -160,12 +150,15 @@ TH3D *AliCFGridSparse::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
   //
 
   TH3D *hist=fData->Projection(ivar1,ivar2,ivar3); 
+  hist->SetXTitle(GetVarTitle(ivar1));
+  hist->SetYTitle(GetVarTitle(ivar2));
+  hist->SetZTitle(GetVarTitle(ivar3));
+  hist->SetTitle(Form("%s: projection on %s-%s-%s",GetTitle(),GetVarTitle(ivar1),GetVarTitle(ivar2),GetVarTitle(ivar3)));
   return hist;
-
 }
 
 //___________________________________________________________________
-AliCFGridSparse* AliCFGridSparse::Project(Int_t nVars, Int_t* vars, Double_t* varMin, Double_t* varMax) const
+AliCFGridSparse* AliCFGridSparse::Project(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax) const
 {
   //
   // projects the grid on the nVars dimensions defined in vars.
@@ -175,7 +168,7 @@ AliCFGridSparse* AliCFGridSparse::Project(Int_t nVars, Int_t* vars, Double_t* va
   // binning for new grid
   Int_t* bins = new Int_t[nVars];
   for (Int_t iVar=0; iVar<nVars; iVar++) {
-    bins[iVar] = fNVarBins[vars[iVar]];
+    bins[iVar] = GetNBins(vars[iVar]);
   }
   
   // create new grid sparse
@@ -184,7 +177,7 @@ AliCFGridSparse* AliCFGridSparse::Project(Int_t nVars, Int_t* vars, Double_t* va
   //set the range in the THnSparse to project
   THnSparse* clone = ((THnSparse*)fData->Clone());
   if (varMin && varMax) {
-    for (Int_t iAxis=0; iAxis<fNVar; iAxis++) {
+    for (Int_t iAxis=0; iAxis<GetNVar(); iAxis++) {
       clone->GetAxis(iAxis)->SetRangeUser(varMin[iAxis],varMax[iAxis]);
     }
   }
@@ -194,53 +187,27 @@ AliCFGridSparse* AliCFGridSparse::Project(Int_t nVars, Int_t* vars, Double_t* va
   return out;
 }
 
+
 //____________________________________________________________________
-Float_t AliCFGridSparse::GetOverFlows(Int_t ivar) const
+Float_t AliCFGridSparse::GetBinCenter(Int_t ivar, Int_t ibin) const
 {
   //
-  // Returns exclusive overflows in variable ivar
-  //
-  Int_t* bin = new Int_t[fNVar];
-  memset(bin, 0, sizeof(Int_t) * fNVar);
-  Float_t ovfl=0.;
-  for (Long64_t i = 0; i < fData->GetNbins(); ++i) {
-    Double_t v = fData->GetBinContent(i, bin);
-    Bool_t add=kTRUE;
-    for(Int_t j=0;j<fNVar;j++){
-      if(ivar==j)continue;
-      if((bin[j]==0) || (bin[j]==fNVarBins[j]+1))add=kFALSE;
-    }
-    if(bin[ivar]==fNVarBins[ivar]+1 && add) ovfl+=v;
-  }
-
-  delete[] bin;
-  return ovfl;
+  // Returns the center of specified bin for variable axis ivar
+  // 
+  
+  return (Float_t) fData->GetAxis(ivar)->GetBinCenter(ibin);
 }
 
 //____________________________________________________________________
-Float_t AliCFGridSparse::GetUnderFlows(Int_t ivar) const
+Float_t AliCFGridSparse::GetBinSize(Int_t ivar, Int_t ibin) const
 {
   //
-  // Returns exclusive overflows in variable ivar
-  //
-  Int_t* bin = new Int_t[fNVar];
-  memset(bin, 0, sizeof(Int_t) * fNVar);
-  Float_t unfl=0.;
-  for (Long64_t i = 0; i < fData->GetNbins(); ++i) {
-    Double_t v = fData->GetBinContent(i, bin);
-    Bool_t add=kTRUE;
-    for(Int_t j=0;j<fNVar;j++){
-      if(ivar==j)continue;
-      if((bin[j]==0) || (bin[j]==fNVarBins[j]+1))add=kFALSE;
-    }
-    if(bin[ivar]==0 && add) unfl+=v;
-  }
-
-  delete[] bin;
-  return unfl;
+  // Returns the size of specified bin for variable axis ivar
+  // 
+  
+  return (Float_t) fData->GetAxis(ivar)->GetBinUpEdge(ibin) - fData->GetAxis(ivar)->GetBinLowEdge(ibin);
 }
 
-
 //____________________________________________________________________
 Float_t AliCFGridSparse::GetEntries() const
 {
@@ -252,22 +219,16 @@ Float_t AliCFGridSparse::GetEntries() const
 }
 
 //____________________________________________________________________
-Float_t AliCFGridSparse::GetElement(Int_t index) const
+Float_t AliCFGridSparse::GetElement(Long_t index) const
 {
   //
-  // Returns content of grid element index according to the
-  // linear indexing in AliCFFrame
+  // Returns content of grid element index 
   //
-  Int_t *bin = new Int_t[fNVar];
-  GetBinIndex(index, bin);
-  for(Int_t i=0;i<fNVar;i++)fIndex[i]=bin[i]+1; //consistency with AliCFGrid
-  Float_t val=GetElement(fIndex);
-  delete [] bin;
-  return val; 
   
+  return fData->GetBinContent(index);
 }
 //____________________________________________________________________
-Float_t AliCFGridSparse::GetElement(Int_t *bin) const
+Float_t AliCFGridSparse::GetElement(const Int_t *bin) const
 {
   //
   // Get the content in a bin corresponding to a set of bin indexes
@@ -276,38 +237,28 @@ Float_t AliCFGridSparse::GetElement(Int_t *bin) const
 
 }  
 //____________________________________________________________________
-Float_t AliCFGridSparse::GetElement(Double_t *var) const
+Float_t AliCFGridSparse::GetElement(const Double_t *var) const
 {
   //
   // Get the content in a bin corresponding to a set of input variables
   //
 
-  Long_t index=fData->GetBin(var,kFALSE); //this is the THnSparse index (do not allocate new cells if content is empty)
-  if(index<0){
-    return 0.;
-  }else{
-    return fData->GetBinContent(index);
-  }
+  Long_t index = fData->GetBin(var,kFALSE);
+  if (index<0) return 0.;
+  return fData->GetBinContent(index);
 } 
 
 //____________________________________________________________________
-Float_t AliCFGridSparse::GetElementError(Int_t index) const
+Float_t AliCFGridSparse::GetElementError(Long_t index) const
 {
   //
-  // Returns the error on the content of a bin according to a linear
-  // indexing in AliCFFrame
+  // Returns the error on the content 
   //
 
-  Int_t *bin = new Int_t[fNVar];
-  GetBinIndex(index, bin);
-  for(Int_t i=0;i<fNVar;i++)fIndex[i]=bin[i]+1; //consistency with AliCFGrid
-  Float_t val=GetElementError(fIndex);
-  delete [] bin;
-  return val;
-
+  return fData->GetBinContent(index);
 }
 //____________________________________________________________________
-Float_t AliCFGridSparse::GetElementError(Int_t *bin) const
+Float_t AliCFGridSparse::GetElementError(const Int_t *bin) const
 {
  //
   // Get the error in a bin corresponding to a set of bin indexes
@@ -316,71 +267,64 @@ Float_t AliCFGridSparse::GetElementError(Int_t *bin) const
 
 }  
 //____________________________________________________________________
-Float_t AliCFGridSparse::GetElementError(Double_t *var) const
+Float_t AliCFGridSparse::GetElementError(const Double_t *var) const
 {
   //
   // Get the error in a bin corresponding to a set of input variables
   //
 
   Long_t index=fData->GetBin(var,kFALSE); //this is the THnSparse index (do not allocate new cells if content is empy)
-  if(index<0){
-    return 0.;
-  }else{
-    return fData->GetBinError(index);
-  }
+  if (index<0) return 0.;
+  return fData->GetBinError(index);
 } 
 
-
 //____________________________________________________________________
-void AliCFGridSparse::SetElement(Int_t index, Float_t val)
+void AliCFGridSparse::SetElement(Long_t index, Float_t val)
 {
   //
-  // Sets grid element iel to val (linear indexing) in AliCFFrame
+  // Sets grid element value
   //
-  Int_t *bin = new Int_t[fNVar];
-  GetBinIndex(index, bin);
-  for(Int_t i=0;i<fNVar;i++)fIndex[i]=bin[i]+1;
-  SetElement(fIndex,val);
-  delete [] bin;
+  Int_t* bin = new Int_t[GetNVar()];
+  fData->GetBinContent(index,bin); //affects the bin coordinates
+  SetElement(bin,val);
+  delete [] bin ;
 }
+
 //____________________________________________________________________
-void AliCFGridSparse::SetElement(Int_t *bin, Float_t val)
+void AliCFGridSparse::SetElement(const Int_t *bin, Float_t val)
 {
   //
   // Sets grid element of bin indeces bin to val
   //
-  
-  AliWarning("Important: bins should be numbered from 1 to NBins");
   fData->SetBinContent(bin,val);
 }
 //____________________________________________________________________
-void AliCFGridSparse::SetElement(Double_t *var, Float_t val) 
+void AliCFGridSparse::SetElement(const Double_t *var, Float_t val) 
 {
   //
   // Set the content in a bin to value val corresponding to a set of input variables
   //
-  Long_t index=fData->GetBin(var); //THnSparse index: allocate the cell
-  Int_t *bin = new Int_t[fNVar];
+  Long_t index=fData->GetBin(var,kTRUE); //THnSparse index: allocate the cell
+  Int_t *bin = new Int_t[GetNVar()];
   fData->GetBinContent(index,bin); //trick to access the array of bins
-  fData->SetBinContent(bin,val);
+  SetElement(bin,val);
   delete [] bin;
-
 }
 
 //____________________________________________________________________
-void AliCFGridSparse::SetElementError(Int_t index, Float_t val)
+void AliCFGridSparse::SetElementError(Long_t index, Float_t val)
 {
   //
   // Sets grid element iel error to val (linear indexing) in AliCFFrame
   //
-  Int_t *bin = new Int_t[fNVar];
-  GetBinIndex(index, bin);
-  for(Int_t i=0;i<fNVar;i++)fIndex[i]=bin[i]+1;
-  SetElementError(fIndex,val);
+  Int_t *bin = new Int_t[GetNVar()];
+  fData->GetBinContent(index,bin);
+  SetElementError(bin,val);
   delete [] bin;
 }
+
 //____________________________________________________________________
-void AliCFGridSparse::SetElementError(Int_t *bin, Float_t val)
+void AliCFGridSparse::SetElementError(const Int_t *bin, Float_t val)
 {
   //
   // Sets grid element error of bin indeces bin to val
@@ -388,15 +332,15 @@ void AliCFGridSparse::SetElementError(Int_t *bin, Float_t val)
   fData->SetBinError(bin,val);
 }
 //____________________________________________________________________
-void AliCFGridSparse::SetElementError(Double_t *var, Float_t val) 
+void AliCFGridSparse::SetElementError(const Double_t *var, Float_t val) 
 {
   //
   // Set the error in a bin to value val corresponding to a set of input variables
   //
   Long_t index=fData->GetBin(var); //THnSparse index
-  Int_t *bin = new Int_t[fNVar];
+  Int_t *bin = new Int_t[GetNVar()];
   fData->GetBinContent(index,bin); //trick to access the array of bins
-  fData->SetBinError(bin,val);
+  SetElementError(bin,val);
   delete [] bin;
 }
 
@@ -409,140 +353,120 @@ void AliCFGridSparse::SumW2()
   if(!fSumW2){
     fData->CalculateErrors(kTRUE); 
   }
-
   fSumW2=kTRUE;
 }
 
 //____________________________________________________________________
-void AliCFGridSparse::Add(const AliCFVGrid* aGrid, Double_t c)
+void AliCFGridSparse::Add(const AliCFGridSparse* aGrid, Double_t c)
 {
   //
   //add aGrid to the current one
   //
 
-
-  if(aGrid->GetNVar()!=fNVar){
-    AliInfo("Different number of variables, cannot add the grids");
+  if (aGrid->GetNVar() != GetNVar()){
+    AliError("Different number of variables, cannot add the grids");
     return;
   } 
   
-  if(!fSumW2  && aGrid->GetSumW2())SumW2();
-
-  fData->Add(((AliCFGridSparse*)aGrid)->GetGrid(),c);
+  if (!fSumW2  && aGrid->GetSumW2()) SumW2();
+  fData->Add(aGrid->GetGrid(),c);
 }
 
 //____________________________________________________________________
-void AliCFGridSparse::Add(const AliCFVGrid* aGrid1, const AliCFVGrid* aGrid2, Double_t c1,Double_t c2)
+void AliCFGridSparse::Add(const AliCFGridSparse* aGrid1, const AliCFGridSparse* aGrid2, Double_t c1,Double_t c2)
 {
   //
   //Add aGrid1 and aGrid2 and deposit the result into the current one
   //
 
-  if(fNVar!=aGrid1->GetNVar()|| fNVar!=aGrid2->GetNVar()){
+  if (GetNVar() != aGrid1->GetNVar() || GetNVar() != aGrid2->GetNVar()) {
     AliInfo("Different number of variables, cannot add the grids");
     return;
   } 
   
-  if(!fSumW2  && (aGrid1->GetSumW2() || aGrid2->GetSumW2()))SumW2();
-
+  if (!fSumW2  && (aGrid1->GetSumW2() || aGrid2->GetSumW2())) SumW2();
 
   fData->Reset();
-  fData->Add(((AliCFGridSparse*)aGrid1)->GetGrid(),c1);
-  fData->Add(((AliCFGridSparse*)aGrid2)->GetGrid(),c2);
-
+  fData->Add(aGrid1->GetGrid(),c1);
+  fData->Add(aGrid2->GetGrid(),c2);
 }
 
 //____________________________________________________________________
-void AliCFGridSparse::Multiply(const AliCFVGrid* aGrid, Double_t c)
+void AliCFGridSparse::Multiply(const AliCFGridSparse* aGrid, Double_t c)
 {
   //
   // Multiply aGrid to the current one
   //
 
-
-  if(aGrid->GetNVar()!=fNVar){
-    AliInfo("Different number of variables, cannot multiply the grids");
+  if (aGrid->GetNVar() != GetNVar()) {
+    AliError("Different number of variables, cannot multiply the grids");
     return;
   } 
   
-  if(!fSumW2  && aGrid->GetSumW2())SumW2();
-
-  THnSparse *h= ((AliCFGridSparse*)aGrid)->GetGrid();
-
+  if(!fSumW2  && aGrid->GetSumW2()) SumW2();
+  THnSparse *h = aGrid->GetGrid();
   fData->Multiply(h);
   fData->Scale(c);
-
 }
 
 //____________________________________________________________________
-void AliCFGridSparse::Multiply(const AliCFVGrid* aGrid1, const AliCFVGrid* aGrid2, Double_t c1,Double_t c2)
+void AliCFGridSparse::Multiply(const AliCFGridSparse* aGrid1, const AliCFGridSparse* aGrid2, Double_t c1,Double_t c2)
 {
   //
   //Multiply aGrid1 and aGrid2 and deposit the result into the current one
   //
 
-  if(fNVar!=aGrid1->GetNVar()|| fNVar!=aGrid2->GetNVar()){
-    AliInfo("Different number of variables, cannot multiply the grids");
+  if (GetNVar() != aGrid1->GetNVar() || GetNVar() != aGrid2->GetNVar()) {
+    AliError("Different number of variables, cannot multiply the grids");
     return;
-  } 
+  }
   
-  if(!fSumW2  && (aGrid1->GetSumW2() || aGrid2->GetSumW2()))SumW2();
-
+  if(!fSumW2  && (aGrid1->GetSumW2() || aGrid2->GetSumW2())) SumW2();
 
   fData->Reset();
-  THnSparse *h1= ((AliCFGridSparse*)aGrid1)->GetGrid();
-  THnSparse *h2= ((AliCFGridSparse*)aGrid2)->GetGrid();
+  THnSparse *h1 = aGrid1->GetGrid();
+  THnSparse *h2 = aGrid2->GetGrid();
   h2->Multiply(h1);
   h2->Scale(c1*c2);
   fData->Add(h2);
 }
 
-
-
 //____________________________________________________________________
-void AliCFGridSparse::Divide(const AliCFVGrid* aGrid, Double_t c)
+void AliCFGridSparse::Divide(const AliCFGridSparse* aGrid, Double_t c)
 {
   //
   // Divide aGrid to the current one
   //
 
-
-  if(aGrid->GetNVar()!=fNVar){
-    AliInfo("Different number of variables, cannot divide the grids");
+  if (aGrid->GetNVar() != GetNVar()) {
+    AliError("Different number of variables, cannot divide the grids");
     return;
   } 
   
-  if(!fSumW2  && aGrid->GetSumW2())SumW2();
-
-  THnSparse *h= ((AliCFGridSparse*)aGrid)->GetGrid();
+  if (!fSumW2  && aGrid->GetSumW2()) SumW2();
 
+  THnSparse *h = aGrid->GetGrid();
   fData->Divide(h);
   fData->Scale(c);
-
 }
 
 //____________________________________________________________________
-void AliCFGridSparse::Divide(const AliCFVGrid* aGrid1, const AliCFVGrid* aGrid2, Double_t c1,Double_t c2, Option_t *option)
+void AliCFGridSparse::Divide(const AliCFGridSparse* aGrid1, const AliCFGridSparse* aGrid2, Double_t c1,Double_t c2, Option_t *option)
 {
   //
   //Divide aGrid1 and aGrid2 and deposit the result into the current one
-  //bynomial errors are supported
+  //binomial errors are supported
   //
 
-  if(fNVar!=aGrid1->GetNVar()|| fNVar!=aGrid2->GetNVar()){
-    AliInfo("Different number of variables, cannot divide the grids");
+  if (GetNVar() != aGrid1->GetNVar() || GetNVar() != aGrid2->GetNVar()) {
+    AliError("Different number of variables, cannot divide the grids");
     return;
   } 
-//   if(fNDim!=aGrid1->GetNDim()|| fNDim!=aGrid2->GetNDim()){
-//     AliInfo("Different number of dimensions, cannot divide the grids!");
-//     return;
-//   } 
   
-  if(!fSumW2  && (aGrid1->GetSumW2() || aGrid2->GetSumW2()))SumW2();
+  if (!fSumW2  && (aGrid1->GetSumW2() || aGrid2->GetSumW2())) SumW2();
 
-
-  THnSparse *h1= ((AliCFGridSparse*)aGrid1)->GetGrid();
-  THnSparse *h2= ((AliCFGridSparse*)aGrid2)->GetGrid();
+  THnSparse *h1= aGrid1->GetGrid();
+  THnSparse *h2= aGrid2->GetGrid();
   fData->Divide(h1,h2,c1,c2,option);
 }
 
@@ -556,114 +480,328 @@ void AliCFGridSparse::Rebin(const Int_t* group)
   // a given axis has to be divisible by the rebin group.
   //
 
-  for(Int_t i=0;i<fNVar;i++){
-    if(group[i]!=1)AliInfo(Form(" merging bins along dimension %i in groups of %i bins", i,group[i]));
+  for(Int_t i=0;i<GetNVar();i++){
+    if (group[i]!=1) AliInfo(Form(" merging bins along dimension %i in groups of %i bins", i,group[i]));
   }
 
   THnSparse *rebinned =fData->Rebin(group);
   fData->Reset();
   fData = rebinned;
+}
+//____________________________________________________________________
+void AliCFGridSparse::Scale(Long_t index, const Double_t *fact)
+{
+  //
+  //scale content of a certain cell by (positive) fact (with error)
+  //
 
-  //redefine the needed stuff
+  if (GetElement(index)==0 || fact[0]==0) return;
 
-  Int_t ndimTot=1;
-  Int_t nbinTot=0;
+  Double_t in[2], out[2];
+  in[0]=GetElement(index);
+  in[1]=GetElementError(index);
+  GetScaledValues(fact,in,out);
+  SetElement(index,out[0]);
+  if (fSumW2) SetElementError(index,out[1]);
+}
+//____________________________________________________________________
+void AliCFGridSparse::Scale(const Int_t *bin, const Double_t *fact)
+{
+  //
+  //scale content of a certain cell by (positive) fact (with error)
+  //
+  if(GetElement(bin)==0 || fact[0]==0)return;
 
-  //number of bins in each dimension, auxiliary variables
+  Double_t in[2], out[2];
+  in[0]=GetElement(bin);
+  in[1]=GetElementError(bin);
+  GetScaledValues(fact,in,out);
+  SetElement(bin,out[0]);
+  if(fSumW2)SetElementError(bin,out[1]);
+  
+}
+//____________________________________________________________________
+void AliCFGridSparse::Scale(const Double_t *var, const Double_t *fact) 
+{
+  //
+  //scale content of a certain cell by (positive) fact (with error)
+  //
+  if(GetElement(var)==0 || fact[0]==0)return;
 
-  for(Int_t ivar=0;ivar<fNVar;ivar++){
-    Int_t nbins = fData->GetAxis(ivar)->GetNbins();
-    fNVarBins[ivar]=nbins;
-    ndimTot*=fNVarBins[ivar];
-    nbinTot+=(fNVarBins[ivar]+1);
-    Int_t offset=0;
-    for(Int_t i =0;i<ivar;i++)offset+=(fNVarBins[i]+1);      
-    fOffset[ivar]=offset;
-    Int_t prod=1;
-    for(Int_t i=0;i<ivar;i++)prod*=fNVarBins[i];
-    fProduct[ivar]=prod;
+  Double_t in[2], out[2];
+  in[0]=GetElement(var);
+  in[1]=GetElementError(var);
+  GetScaledValues(fact,in,out);
+  SetElement(var,out[0]);
+  if(fSumW2)SetElementError(var,out[1]);
+  
+}
+//____________________________________________________________________
+void AliCFGridSparse::Scale(const Double_t* fact)
+{
+  //
+  //scale contents of the whole grid by fact
+  //
+
+  for (Long_t iel=0; iel<GetNFilledBins(); iel++) {
+    Scale(iel,fact);
   }
+}
+//____________________________________________________________________
+Long_t AliCFGridSparse::GetEmptyBins() const {
+  //
+  // Get empty bins 
+  //
 
-  fNDim=ndimTot;
+  return (GetNBinsTotal() - GetNFilledBins()) ;
+} 
 
-  //now the array of bin limits
+//_____________________________________________________________________
+// Int_t AliCFGridSparse::GetEmptyBins( Double_t *varMin, Double_t* varMax ) const 
+// {
+//   //
+//   // Get empty bins in a range specified by varMin and varMax
+//   //
+
+//   Int_t *indexMin = new Int_t[GetNVar()];
+//   Int_t *indexMax = new Int_t[GetNVar()];
+
+//   //Find out the min and max bins
+
+//   for (Int_t i=0;i<GetNVar();i++) {
+//     Double_t xmin=varMin[i]; // the min values  
+//     Double_t xmax=varMax[i]; // the min values  
+//     Int_t nbins = fData->GetAxis(i)->GetNbins()+1;
+//     Double_t *bins=new Double_t[nbins];
+//     for(Int_t ibin =0;ibin<nbins;ibin++){
+//      bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
+//     }
+//     indexMin[i] = TMath::BinarySearch(nbins,bins,xmin);
+//     indexMax[i] = TMath::BinarySearch(nbins,bins,xmax);
+//     delete [] bins;
+//   }
+
+//   Int_t val=0;
+//   for(Int_t i=0;i<fNDim;i++){
+//     for (Int_t j=0;j<GetNVar();j++)fIndex[j]=GetBinIndex(j,i);
+//     Bool_t isIn=kTRUE;
+//     for (Int_t j=0;j<GetNVar();j++){
+//       if(!(fIndex[j]>=indexMin[j] && fIndex[j]<=indexMax[j]))isIn=kFALSE;   
+//     }
+//     if(isIn && GetElement(i)<=0)val++;     
+//   }
+//   AliInfo(Form(" the empty bins = %i ",val)); 
+
+//   delete [] indexMin;
+//   delete [] indexMax;
+//   return val;
+// } 
+
+//____________________________________________________________________
+Int_t AliCFGridSparse::CheckStats(Double_t thr) const
+{
+  //
+  // Count the cells below a certain threshold
+  //
+  Int_t ncellsLow=0;
+  for (Int_t i=0; i<GetNBinsTotal(); i++) {
+    if (GetElement(i)<thr) ncellsLow++;
+  }
+  return ncellsLow;
+}
 
-  delete fVarBinLimits;
-  fNVarBinLimits=nbinTot;
-  fVarBinLimits=new Double_t[fNVarBinLimits];
+//_____________________________________________________________________
+Double_t AliCFGridSparse::GetIntegral() const 
+{
+  //
+  // Get full Integral
+  //
+  return fData->ComputeIntegral();  
+} 
 
-  for(Int_t ivar=0;ivar<fNVar;ivar++){
-    Double_t low = fData->GetAxis(ivar)->GetXmin();
-    Double_t high = fData->GetAxis(ivar)->GetXmax();    
-    const TArrayD *xbins = fData->GetAxis(ivar)->GetXbins();
-    if (xbins->fN == 0){
-      for(Int_t ibin=0;ibin<=fNVarBins[ivar];ibin++){
-       fVarBinLimits[ibin+fOffset[ivar]] = low + ibin*(high-low)/((Double_t) fNVarBins[ivar]);
-      }
-    }
-    else{
-      
-      for(Int_t ibin=0;ibin<=fNVarBins[ivar];ibin++) {
-       fVarBinLimits[ibin+fOffset[ivar]] = xbins->At(ibin);
-      }
-    }
-  }   
+//_____________________________________________________________________
+// Double_t AliCFGridSparse::GetIntegral(Int_t *binMin, Int_t* binMax ) const 
+// {
+//   //
+//   // Get Integral in a range of bin indeces (extremes included)
+//   //
+
+//   Double_t val=0;
+
+//   for(Int_t i=0;i<GetNVar();i++){
+//     if(binMin[i]<1)binMin[i]=1;
+//     if(binMax[i]>fNVarBins[i])binMax[i]=fNVarBins[i];
+//     if((binMin[i]>binMax[i])){
+//       AliInfo(Form(" Bin indices in variable %i in reverse order, please check!", i));
+//       return val;
+//     }
+//   }
+//   val=GetSum(0,binMin,binMax);
+
+//   return val;
+// } 
+
+//_____________________________________________________________________
+// Double_t AliCFGridSparse::GetIntegral(Double_t *varMin, Double_t* varMax ) const 
+// {
+//   //
+//   // Get Integral in a range (extremes included)
+//   //
+
+//   Int_t *indexMin=new Int_t[GetNVar()];
+//   Int_t *indexMax=new Int_t[GetNVar()];
+
+//   //Find out the min and max bins
+
+//   for(Int_t i=0;i<GetNVar();i++){
+//     Double_t xmin=varMin[i]; // the min values  
+//     Double_t xmax=varMax[i]; // the min values  
+//     Int_t nbins=fNVarBins[i]+1;
+//     Double_t *bins=new Double_t[nbins];
+//     for(Int_t ibin =0;ibin<nbins;ibin++){
+//      bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
+//     }
+//     indexMin[i] = TMath::BinarySearch(nbins,bins,xmin);
+//     indexMax[i] = TMath::BinarySearch(nbins,bins,xmax);
+//     delete [] bins;
+//   }
+
+//   //move to the TH/THnSparse convention in N-dim bin numbering 
+//   for(Int_t i=0;i<GetNVar();i++){
+//     indexMin[i]+=1;
+//     indexMax[i]+=1;
+//   }
+
+//   Double_t val=GetIntegral(indexMin,indexMax);
+
+//   delete [] indexMin;
+//   delete [] indexMax;
+
+//   return val;
+// } 
+
+// //_____________________________________________________________________
+// Double_t AliCFGridSparse::GetSum(Int_t ivar, Int_t *binMin, Int_t* binMax) const 
+// {
+//   //
+//   // recursively add over nested loops.... 
+//   //
+
+//   static Double_t val;
+//   if (ivar==0) val=0.;
+//   for(Int_t ibin=binMin[ivar]-1 ; ibin<=binMax[ivar]-1 ; ibin++){
+//     //-1 is to move from TH/ThnSparse N-dim bin convention to one in AliCFFrame
+//     fIndex[ivar]=ibin;
+//     if(ivar<GetNVar()-1) {
+//       val=GetSum(ivar+1,binMin,binMax);
+//     }
+//     else {
+//       Int_t iel=GetBinIndex(fIndex);
+//       val+=GetElement(iel);
+//     }
+//   }
+  
+//   return val;
+// }
+
+//____________________________________________________________________
+Long64_t AliCFGridSparse::Merge(TCollection* list)
+{
+  //
+  // Merge a list of AliCFGridSparse 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;
+  
+  Int_t count = 0;
+  while ((obj = iter->Next())) {
+    AliCFGridSparse* entry = dynamic_cast<AliCFGridSparse*> (obj);
+    if (entry == 0) 
+      continue;
+    this->Add(entry);
+    count++;
+  }
+
+  return count+1;
 }
+
+//____________________________________________________________________
+void AliCFGridSparse::GetScaledValues(const Double_t *fact, const Double_t *in, Double_t *out) const{
+  //
+  // scale input *in and its error by (positive) fact (with error)
+  // and erite it to *out
+  //
+  out[0]=in[0]*fact[0];
+  out[1]=TMath::Sqrt(in[1]*in[1]/in[0]/in[0]
+                    +fact[1]*fact[1]/fact[0]/fact[0])*out[0];
+    
+}
+
 //____________________________________________________________________
 void AliCFGridSparse::Copy(TObject& c) const
 {
   //
   // copy function
   //
+  AliCFFrame::Copy(c);
   AliCFGridSparse& target = (AliCFGridSparse &) c;
-
-  if(fData)target.fData = fData;
+  target.fSumW2 = fSumW2 ;
+  if (fData) {
+    target.fData = (THnSparse*)fData->Clone();
+  }
 }
 
 //____________________________________________________________________
-TH1D* AliCFGridSparse::Slice(Int_t iVar, Double_t *varMin, Double_t *varMax) const
+TH1D* AliCFGridSparse::Slice(Int_t iVar, const Double_t *varMin, const Double_t *varMax) const
 {
   //
   // return a slice (1D-projection) on variable iVar while axis ranges are defined with varMin,varMax
   // arrays varMin and varMax contain the min and max values of each variable.
-  // therefore varMin and varMax must have their dimensions equal to fNVar
+  // therefore varMin and varMax must have their dimensions equal to GetNVar()
   //
   
   THnSparse* clone = (THnSparse*)fData->Clone();
-  for (Int_t iAxis=0; iAxis<fNVar; iAxis++) {
+  for (Int_t iAxis=0; iAxis<GetNVar(); iAxis++) {
     clone->GetAxis(iAxis)->SetRangeUser(varMin[iAxis],varMax[iAxis]);
   }
   return clone->Projection(iVar);
 }
 
 //____________________________________________________________________
-TH2D* AliCFGridSparse::Slice(Int_t iVar1, Int_t iVar2, Double_t *varMin, Double_t *varMax) const
+TH2D* AliCFGridSparse::Slice(Int_t iVar1, Int_t iVar2, const Double_t *varMin, const Double_t *varMax) const
 {
   //
   // return a slice (2D-projection) on variables iVar1 and iVar2 while axis ranges are defined with varMin,varMax
   // arrays varMin and varMax contain the min and max values of each variable.
-  // therefore varMin and varMax must have their dimensions equal to fNVar
+  // therefore varMin and varMax must have their dimensions equal to GetNVar()
   //
   
   THnSparse* clone = (THnSparse*)fData->Clone();
-  for (Int_t iAxis=0; iAxis<fNVar; iAxis++) {
+  for (Int_t iAxis=0; iAxis<GetNVar(); iAxis++) {
     clone->GetAxis(iAxis)->SetRangeUser(varMin[iAxis],varMax[iAxis]);
   }
   return clone->Projection(iVar1,iVar2);
 }
 
 //____________________________________________________________________
-TH3D* AliCFGridSparse::Slice(Int_t iVar1, Int_t iVar2, Int_t iVar3, Double_t *varMin, Double_t *varMax) const
+TH3D* AliCFGridSparse::Slice(Int_t iVar1, Int_t iVar2, Int_t iVar3, const Double_t *varMin, const Double_t *varMax) const
 {
   //
   // return a slice (3D-projection) on variables iVar1, iVar2 and iVar3 while axis ranges are defined with varMin,varMax
   // arrays varMin and varMax contain the min and max values of each variable.
-  // therefore varMin and varMax must have their dimensions equal to fNVar
+  // therefore varMin and varMax must have their dimensions equal to GetNVar()
   //
 
   THnSparse* clone = (THnSparse*)fData->Clone();
-  for (Int_t iAxis=0; iAxis<fNVar; iAxis++) {
+  for (Int_t iAxis=0; iAxis<GetNVar(); iAxis++) {
     clone->GetAxis(iAxis)->SetRangeUser(varMin[iAxis],varMax[iAxis]);
   }
   return clone->Projection(iVar1,iVar2,iVar3);
@@ -679,11 +817,11 @@ void AliCFGridSparse::SetRangeUser(Int_t iVar, Double_t varMin, Double_t varMax)
 }
 
 //____________________________________________________________________
-void AliCFGridSparse::SetRangeUser(Double_t *varMin, Double_t *varMax) {
+void AliCFGridSparse::SetRangeUser(const Double_t *varMin, const Double_t *varMax) {
   //
-  // set range of every axis. varMin and varMax must be of dimension fNVar
+  // set range of every axis. varMin and varMax must be of dimension GetNVar()
   //
-  for (Int_t iAxis=0; iAxis<fNVar ; iAxis++) { // set new range for every axis
+  for (Int_t iAxis=0; iAxis<GetNVar() ; iAxis++) { // set new range for every axis
     SetRangeUser(iAxis,varMin[iAxis],varMax[iAxis]);
   }
   AliWarning("THnSparse axes ranges have been modified");
@@ -691,5 +829,58 @@ void AliCFGridSparse::SetRangeUser(Double_t *varMin, Double_t *varMax) {
 
 //____________________________________________________________________
 void AliCFGridSparse::UseAxisRange(Bool_t b) const {
-  for (Int_t iAxis=0; iAxis<fNVar; iAxis++) fData->GetAxis(iAxis)->SetBit(TAxis::kAxisRange,b);
+  for (Int_t iAxis=0; iAxis<GetNVar(); iAxis++) fData->GetAxis(iAxis)->SetBit(TAxis::kAxisRange,b);
+}
+
+//____________________________________________________________________
+Float_t AliCFGridSparse::GetOverFlows(Int_t ivar, Bool_t exclusive) const
+{
+  //
+  // Returns overflows in variable ivar
+  // Set 'exclusive' to true for an exclusive check on variable ivar
+  //
+  Int_t* bin = new Int_t[GetNVar()];
+  memset(bin, 0, sizeof(Int_t) * GetNVar());
+  Float_t ovfl=0.;
+  for (Long64_t i = 0; i < fData->GetNbins(); i++) {
+    Double_t v = fData->GetBinContent(i, bin);
+    Bool_t add=kTRUE;
+    if (exclusive) {
+      for(Int_t j=0;j<GetNVar();j++){
+       if(ivar==j)continue;
+       if((bin[j]==0) || (bin[j]==GetNBins(j)+1))add=kFALSE;
+      }
+    }
+    if(bin[ivar]==GetNBins(ivar)+1 && add) ovfl+=v;
+  }
+
+  delete[] bin;
+  return ovfl;
+}
+
+//____________________________________________________________________
+Float_t AliCFGridSparse::GetUnderFlows(Int_t ivar, Bool_t exclusive) const
+{
+  //
+  // Returns exclusive overflows in variable ivar
+  // Set 'exclusive' to true for an exclusive check on variable ivar
+  //
+  Int_t* bin = new Int_t[GetNVar()];
+  memset(bin, 0, sizeof(Int_t) * GetNVar());
+  Float_t unfl=0.;
+  for (Long64_t i = 0; i < fData->GetNbins(); i++) {
+    Double_t v = fData->GetBinContent(i, bin);
+    Bool_t add=kTRUE;
+    if (exclusive) {
+      for(Int_t j=0;j<GetNVar();j++){
+       if(ivar==j)continue;
+       if((bin[j]==0) || (bin[j]==GetNBins(j)+1))add=kFALSE;
+      }
+    }
+    if(bin[ivar]==0 && add) unfl+=v;
+  }
+
+  delete[] bin;
+  return unfl;
 }
+
index e66f183..4b06bbd 100755 (executable)
 // Author:S.Arcelli, silvia.arcelli@cern.ch
 //--------------------------------------------------------------------//
 
-#include "AliCFVGrid.h"
+#include "AliCFFrame.h"
 #include "THnSparse.h"
 #include "AliLog.h"
+#include "TAxis.h"
+
 class TH1D;
 class TH2D;
 class TH3D;
 
-class AliCFGridSparse : public AliCFVGrid
+class AliCFGridSparse : public AliCFFrame
 {
  public:
   AliCFGridSparse();
-  AliCFGridSparse(const Char_t* name,const Char_t* title);
-  AliCFGridSparse(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t* nBinIn, const Double_t  *binLimitsIn=0);
-  AliCFGridSparse(const AliCFGridSparse & c);
-  
+  AliCFGridSparse(const Char_t* name, const Char_t* title);
+  AliCFGridSparse(const Char_t* name, const Char_t* title, Int_t nVarIn, const Int_t* nBinIn);
+  AliCFGridSparse(const AliCFGridSparse& c);
   virtual ~AliCFGridSparse();
-  AliCFGridSparse& operator=(const AliCFGridSparse& corr) ;
-  virtual void  SetBinLimits(Int_t ivar, Double_t * array);
-  
-  virtual void  Fill(Double_t *var, Double_t weight=1.);
+  AliCFGridSparse& operator=(const AliCFGridSparse& c);
+  virtual void Copy(TObject& c) const;
 
-  virtual Float_t GetOverFlows(Int_t var) const;
-  virtual Float_t GetUnderFlows(Int_t var)const;
-  virtual Float_t GetEntries()const;
+  // AliCFFrame functions
+  virtual Int_t      GetNVar() const {return fData->GetNdimensions();}
+  virtual void       PrintBinLimits() const ;
+  virtual void       PrintNBins() const ; 
+  virtual void       SetBinLimits(Int_t ivar, const Double_t * array);
+  virtual void       GetBinLimits(Int_t ivar, Double_t * array) const ;
+  virtual Double_t * GetBinLimits(Int_t ivar) const ;
+  virtual Long_t     GetNBinsTotal() const ;
+  virtual Long_t     GetNFilledBins() const {return fData->GetNbins();}
+  virtual Int_t      GetNBins(Int_t ivar) const {return fData->GetAxis(ivar)->GetNbins();}
+  virtual Int_t *    GetNBins() const ;
+  virtual Float_t    GetBinCenter(Int_t ivar,Int_t ibin) const ;
+  virtual Float_t    GetBinSize  (Int_t ivar,Int_t ibin) const ;
+  //virtual void       GetBinCenters(const Int_t *ibin, Float_t *binCenter) const ;
+  //virtual void       GetBinSizes  (const Int_t *ibin, Float_t *binSizes)  const ;
+  virtual TAxis    * GetAxis(Int_t ivar) const {return fData->GetAxis(ivar);}
 
-  virtual Float_t GetElement(Int_t iel)const; 
-  virtual Float_t GetElement(Int_t *bin)const; 
-  virtual Float_t GetElement(Double_t *var)const; 
+  virtual void          SetVarTitle(Int_t ivar, const Char_t* lab) {fData->GetAxis(ivar)->SetTitle(lab);}
+  virtual const Char_t* GetVarTitle(Int_t ivar) const {return GetAxis(ivar)->GetTitle();}
+  virtual Int_t         GetVar(const Char_t* title) const ; // returns the variable corresponding to the given title
 
-  virtual Float_t GetElementError(Int_t iel)const; 
-  virtual Float_t GetElementError(Int_t *bin)const; 
-  virtual Float_t GetElementError(Double_t *var)const; 
+  // probably not needed anymore
+  //virtual Int_t      GetBinIndex(const Int_t *ibin) const ;
+  //virtual void       GetBinIndex(Int_t iel, const Int_t *ibin) const ;
+  //virtual Int_t      GetBinIndex(Int_t ivar, Int_t ind) const ;
 
-  virtual void SetElement(Int_t iel, Float_t val); 
-  virtual void SetElement(Int_t *bin, Float_t val); 
-  virtual void SetElement(Double_t *var, Float_t val); 
-  virtual void SetElementError(Int_t iel, Float_t val); 
-  virtual void SetElementError(Int_t *bin, Float_t val) ; 
-  virtual void SetElementError(Double_t *var, Float_t val); 
+  virtual void    Fill(const Double_t *var, Double_t weight=1.);
+  virtual Float_t GetEntries()const;
+  virtual Float_t GetElement(Long_t iel)               const; 
+  virtual Float_t GetElement(const Int_t *bin)         const; 
+  virtual Float_t GetElement(const Double_t *var)      const; 
+  virtual Float_t GetElementError(Long_t iel)          const;  
+  virtual Float_t GetElementError(const Int_t *bin)    const; 
+  virtual Float_t GetElementError(const Double_t *var) const; 
+  virtual void    SetElement(Long_t iel, Float_t val); 
+  virtual void    SetElement(const Int_t *bin, Float_t val); 
+  virtual void    SetElement(const Double_t *var, Float_t val); 
+  virtual void    SetElementError(Long_t iel, Float_t val); 
+  virtual void    SetElementError(const Int_t *bin, Float_t val) ; 
+  virtual void    SetElementError(const Double_t *var, Float_t val); 
 
   virtual TH1D*            Project( Int_t ivar) const;
   virtual TH2D*            Project( Int_t ivar1, Int_t ivar2) const;
   virtual TH3D*            Project( Int_t ivar1, Int_t ivar2,Int_t ivar3) const;
-  virtual AliCFGridSparse* Project(Int_t nVars, Int_t* vars, Double_t* varMin, Double_t* varMax) const ;
-  virtual TH1D* Slice(Int_t ivar, Double_t* varMin, Double_t* varMax) const ; 
-  virtual TH2D* Slice(Int_t ivar1, Int_t ivar2, Double_t *varMin, Double_t *varMax) const ;
-  virtual TH3D* Slice(Int_t ivar1, Int_t ivar2, Int_t ivar3, Double_t *varMin, Double_t *varMax) const ;
-  virtual void  SetRangeUser(Int_t iVar, Double_t varMin, Double_t varMax) ;
-  virtual void  SetRangeUser(Double_t* varMin, Double_t* varMax) ;
-
-  virtual void UseAxisRange(Bool_t b) const ;
+  virtual AliCFGridSparse* Project(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax) const ;
+  virtual TH1D*            Slice(Int_t ivar, const Double_t* varMin, const Double_t* varMax) const ; 
+  virtual TH2D*            Slice(Int_t ivar1, Int_t ivar2, const Double_t *varMin, const Double_t *varMax) const ;
+  virtual TH3D*            Slice(Int_t ivar1, Int_t ivar2, Int_t ivar3, const Double_t *varMin, const Double_t *varMax) const ;
+  virtual void             SetRangeUser(Int_t iVar, Double_t varMin, Double_t varMax) ;
+  virtual void             SetRangeUser(const Double_t* varMin, const Double_t* varMax) ;
+  virtual void             UseAxisRange(Bool_t b) const ;
 
   //basic operations
+  virtual void     SumW2();
+  virtual void     Add(const AliCFGridSparse* aGrid, Double_t c=1.);
+  virtual void     Add(const AliCFGridSparse* aGrid1 ,const AliCFGridSparse* aGrid2, Double_t c1=1.,Double_t c2=1.);
+  virtual void     Multiply(const AliCFGridSparse* aGrid, Double_t c=1.);
+  virtual void     Multiply(const AliCFGridSparse* aGrid1,const AliCFGridSparse* aGrid2, Double_t c1=1.,Double_t c2=1.);
+  virtual void     Divide(const AliCFGridSparse* aGrid, Double_t c=1.);
+  virtual void     Divide(const AliCFGridSparse* aGrid1, const AliCFGridSparse* aGrid2, Double_t c1=1., Double_t c2=1.,Option_t *option=0);
+  virtual void     Rebin(const Int_t* group);
+  virtual void     Scale(Long_t iel, const Double_t *fact); 
+  virtual void     Scale(const Int_t* bin, const Double_t *fact); 
+  virtual void     Scale(const Double_t* var, const Double_t *fact); 
+  virtual void     Scale(const Double_t *fact); // To normalize MC to int lumi, for ex. 
+  virtual Int_t    CheckStats(Double_t thr) const;
+  virtual Int_t    GetSumW2() const {return fSumW2;};
+  virtual Double_t GetIntegral() const;
+  //virtual Double_t GetIntegral(const Double_t *varMin, const Double_t *varMax) const;
+  virtual Long64_t Merge(TCollection* list);
 
-  virtual void SumW2();
-  virtual void Add(const AliCFVGrid* aGrid, Double_t c=1.);
-  virtual void Add(const AliCFVGrid* aGrid1 ,const AliCFVGrid* aGrid2, Double_t c1=1.,Double_t c2=1.);
-  virtual void Multiply(const AliCFVGrid* aGrid, Double_t c=1.);
-  virtual void Multiply(const AliCFVGrid* aGrid1,const AliCFVGrid* aGrid2, Double_t c1=1.,Double_t c2=1.);
-  virtual void Divide(const AliCFVGrid* aGrid, Double_t c=1.);
-  virtual void Divide(const AliCFVGrid* aGrid1, const AliCFVGrid* aGrid2, Double_t c1=1., Double_t c2=1.,Option_t *option=0);
+  virtual void     SetGrid(THnSparse* grid) {fData=grid;}
+  THnSparse   *    GetGrid() const {return fData;}
 
-  virtual void Rebin(const Int_t* group);
-  virtual void SetGrid(THnSparse* grid) {fData=grid;}
-  THnSparse   *GetGrid() const {return fData;};//  Getter for the data Container: a THnSparse
+  virtual Float_t GetOverFlows (Int_t var, Bool_t excl=kFALSE) const;
+  virtual Float_t GetUnderFlows(Int_t var, Bool_t excl=kFALSE) const;
+  virtual Long_t  GetEmptyBins() const;
 
-  virtual void Copy(TObject& c) const;
+  // to be implemented
+  //------------------
+  //virtual Int_t    GetEmptyBins(Double_t *varMin,Double_t *varMax) const;
+  //virtual Double_t GetIntegral(Int_t *binMin,Int_t *binMax) const;
 
-  
  protected:
 
-  THnSparse  *fData;//  The data Container: a THnSparse  
-  ClassDef(AliCFGridSparse,2);
+  //protected functions
+  //Float_t  GetSum(Int_t ivar, const Int_t *binMin, const Int_t* binMax) const; 
+  void     GetScaledValues(const Double_t *fact, const Double_t *in, Double_t *out) const;
+
+  // data members:
+  Bool_t      fSumW2    ; // Flag to check if calculation of squared weights enabled
+  THnSparse  *fData     ; // The data Container: a THnSparse  
+
+  ClassDef(AliCFGridSparse,3);
 };
-    
+
+
+//inline functions :
+
+inline Long_t AliCFGridSparse::GetNBinsTotal() const {
+  Long_t n=1;
+  for (Int_t iVar=0; iVar<GetNVar(); iVar++) {
+    n *= fData->GetAxis(iVar)->GetNbins();
+  }
+  return n ;
+}
+
+inline void AliCFGridSparse::PrintNBins() const
+{
+  //
+  // printing the array containing the # of bins  
+  //
+  for (Int_t i=0;i<GetNVar();i++) {
+    AliInfo(Form("bins in axis %i are: %i",i,fData->GetAxis(i)->GetNbins()));
+  }
+} 
+
+inline void AliCFGridSparse::PrintBinLimits() const
+{
+  //
+  // printing the bin limits for each variable  
+  //
+  for (Int_t iVar=0; iVar<GetNVar(); iVar++) {
+    AliInfo(Form("variable %d :",iVar));
+    const Int_t nBins = GetNBins(iVar) ;
+    Double_t *array = new Double_t[nBins+1];
+    GetBinLimits(iVar,array);
+    for (Int_t iBin=0; iBin<nBins; iBin++) {
+      AliInfo(Form("    bin limit index %i is: %e",iBin,array[iBin]));
+    }
+    delete [] array ;
+  }
+}
+
+inline void AliCFGridSparse::GetBinLimits(Int_t ivar, Double_t * array) const {
+  TAxis * axis = fData->GetAxis(ivar) ;
+  Int_t nBins = axis->GetNbins();
+  for (Int_t iBin=0; iBin<nBins; iBin++) array[iBin] = axis->GetBinLowEdge(iBin+1);
+  array[nBins] = axis->GetBinUpEdge(nBins);
+}
+
+inline Int_t* AliCFGridSparse::GetNBins() const {
+  Int_t *bins = new Int_t(GetNVar());
+  for (Int_t iVar=0; iVar<GetNVar(); iVar++) {
+    bins[iVar] = GetNBins(iVar) ;
+  }
+  return bins;
+}
+
+inline Double_t* AliCFGridSparse::GetBinLimits(Int_t ivar) const {
+  Double_t * binLimits = new Double_t[GetNBins(ivar)+1] ;
+  GetBinLimits(ivar,binLimits);
+  return binLimits;
+}
+
+inline Int_t AliCFGridSparse::GetVar(const Char_t* title) const {
+  TString str(title);
+  for (Int_t iVar=0; iVar<GetNVar(); iVar++) {
+    if (!str.CompareTo(GetVarTitle(iVar))) return iVar;
+  }
+  AliError("Variable not found");
+  return -1;
+}
+
 #endif
 
index 1bcbaa6..bc611f6 100644 (file)
@@ -5,9 +5,7 @@
 //--------------------------------------------------------------------//
 //                                                                    //
 // AliCFUnfolding Class                                               //
-// Class to handle general unfolding procedure                        // 
-// For the moment only bayesian unfolding is supported                //
-// The next steps are to add chi2 minimisation and weighting methods  //
+// Class to handle general unfolding procedure using bayesian method  //
 //                                                                    //
 // Author : renaud.vernet@cern.ch                                     //
 //--------------------------------------------------------------------//
diff --git a/CORRFW/AliCFVGrid.cxx b/CORRFW/AliCFVGrid.cxx
deleted file mode 100755 (executable)
index dd984b9..0000000
+++ /dev/null
@@ -1,355 +0,0 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-//--------------------------------------------------------------------//
-//                                                                    //
-// AliCFVGrid Class                                                   //
-// Just an interface to handle both AliCFGrid and AliCFGridSparse     //
-// implementations                                                    //
-//                                                                    //
-// -- Author : S.Arcelli                                              //
-//--------------------------------------------------------------------//
-//
-//
-#include "AliCFVGrid.h"
-#include "TMath.h"
-#include <AliLog.h>
-
-//____________________________________________________________________
-ClassImp(AliCFVGrid)
-
-//____________________________________________________________________
-AliCFVGrid::AliCFVGrid() : 
-  AliCFFrame(),
-  fSumW2(kFALSE)
-{
-  // default constructor
-}
-//____________________________________________________________________
-AliCFVGrid::AliCFVGrid(const Char_t* name, const Char_t* title) : 
-  AliCFFrame(name,title),
-  fSumW2(kFALSE)
-{
-  // default constructor
-}
-
-//____________________________________________________________________
-AliCFVGrid::AliCFVGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn, const Double_t *binLimitsIn) :  
-  AliCFFrame(name,title,nVarIn,nBinIn,binLimitsIn),
-  fSumW2(kFALSE)
-{
-  //
-  // main constructor
-  //
-
-}
-
-//____________________________________________________________________
-AliCFVGrid::AliCFVGrid(const AliCFVGrid& c) : 
-  AliCFFrame(c),
-  fSumW2(c.fSumW2)
-{
-  //
-  // copy constructor
-  //
- ((AliCFVGrid &)c).Copy(*this);
-
-}
-//____________________________________________________________________
-AliCFVGrid::~AliCFVGrid()
-{
-  //
-  // destructor
-  //
-}
-
-//____________________________________________________________________
-AliCFVGrid &AliCFVGrid::operator=(const AliCFVGrid &c)
-{
-  //
-  // assigment operator
-  //
-  if (this != &c)
-    AliCFFrame::operator=(c);
-  return *this;
-} 
-
-//____________________________________________________________________
-void AliCFVGrid::Copy(TObject& c) const
-{
-  //
-  // copy function
-  //
-  AliCFVGrid& target = (AliCFVGrid &) c;
-
-  target.fSumW2=fSumW2;
-}
-
-//____________________________________________________________________
-void AliCFVGrid::Scale(Int_t index, Double_t *fact)
-{
-  //
-  //scale content of a certain cell by (positive) fact (with error)
-  //
-  if(GetElement(index)==0 || fact[0]==0)return;
-
-  Double_t in[2], out[2];
-  in[0]=GetElement(index);
-  in[1]=GetElementError(index);
-  GetScaledValues(fact,in,out);
-  SetElement(index,out[0]);
-  if(fSumW2)SetElementError(index,out[1]);
-}
-//____________________________________________________________________
-void AliCFVGrid::Scale(Int_t *bin, Double_t *fact)
-{
-  //
-  //scale content of a certain cell by (positive) fact (with error)
-  //
-  if(GetElement(bin)==0 || fact[0]==0)return;
-
-  Double_t in[2], out[2];
-  in[0]=GetElement(bin);
-  in[1]=GetElementError(bin);
-  GetScaledValues(fact,in,out);
-  SetElement(bin,out[0]);
-  if(fSumW2)SetElementError(bin,out[1]);
-  
-}
-//____________________________________________________________________
-void AliCFVGrid::Scale(Double_t *var, Double_t *fact) 
-{
-  //
-  //scale content of a certain cell by (positive) fact (with error)
-  //
-  if(GetElement(var)==0 || fact[0]==0)return;
-
-  Double_t in[2], out[2];
-  in[0]=GetElement(var);
-  in[1]=GetElementError(var);
-  GetScaledValues(fact,in,out);
-  SetElement(var,out[0]);
-  if(fSumW2)SetElementError(var,out[1]);
-  
-}
-//____________________________________________________________________
-void AliCFVGrid::Scale( Double_t *fact) 
-{
-  //
-  //scale contents of the whole grid by fact
-  //
-
-  for(Int_t iel=0;iel<fNDim;iel++){
-    Scale(iel,fact);
-  }
-}
-
-//____________________________________________________________________
-Int_t AliCFVGrid::GetEmptyBins() const {
-  //
-  // Get empty bins 
-  //
-  Int_t val=0;
-  for(Int_t i=0;i<fNDim;i++){
-    if(GetElement(i)<=0)val++;     
-  }
-  return val;
-} 
-//_____________________________________________________________________
-Int_t AliCFVGrid::GetEmptyBins( Double_t *varMin, Double_t* varMax ) const 
-{
-  //
-  // Get empty bins in a range
-  //
-
-  Int_t *indexMin=new Int_t[fNVar];
-  Int_t *indexMax=new Int_t[fNVar];
-
-  //Find out the min and max bins
-
-  for(Int_t i=0;i<fNVar;i++){
-    Double_t xmin=varMin[i]; // the min values  
-    Double_t xmax=varMax[i]; // the min values  
-    Int_t nbins=fNVarBins[i]+1;
-    Double_t *bins=new Double_t[nbins];
-    for(Int_t ibin =0;ibin<nbins;ibin++){
-     bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
-    }
-    indexMin[i] = TMath::BinarySearch(nbins,bins,xmin);
-    indexMax[i] = TMath::BinarySearch(nbins,bins,xmax);
-    delete [] bins;
-  }
-
-  Int_t val=0;
-  for(Int_t i=0;i<fNDim;i++){
-    for (Int_t j=0;j<fNVar;j++)fIndex[j]=GetBinIndex(j,i);
-    Bool_t isIn=kTRUE;
-    for (Int_t j=0;j<fNVar;j++){
-      if(!(fIndex[j]>=indexMin[j] && fIndex[j]<=indexMax[j]))isIn=kFALSE;   
-    }
-    if(isIn && GetElement(i)<=0)val++;     
-  }
-  AliInfo(Form(" the empty bins = %i ",val)); 
-
-  delete [] indexMin;
-  delete [] indexMax;
-  return val;
-} 
-//____________________________________________________________________
-Int_t AliCFVGrid::CheckStats(Double_t thr) const
-{
-  //
-  // Count the cells below a certain threshold
-  //
-  Int_t ncellsLow=0;
-  for(Int_t i=0;i<fNDim;i++){
-    if(GetElement(i)<thr)ncellsLow++;
-  }
-  return ncellsLow;
-}
-//_____________________________________________________________________
-Double_t AliCFVGrid::GetIntegral() const 
-{
-  //
-  // Get full Integral
-  //
-  Double_t val=0;
-  for(Int_t i=0;i<fNDim;i++){
-    val+=GetElement(i);     
-  }
-  return val;  
-} 
-//_____________________________________________________________________
-Double_t AliCFVGrid::GetIntegral(Int_t *binMin, Int_t* binMax ) const 
-{
-  //
-  // Get Integral in a range of bin indeces (extremes included)
-  //
-
-  Double_t val=0;
-
-  for(Int_t i=0;i<fNVar;i++){
-    if(binMin[i]<1)binMin[i]=1;
-    if(binMax[i]>fNVarBins[i])binMax[i]=fNVarBins[i];
-    if((binMin[i]>binMax[i])){
-      AliInfo(Form(" Bin indeces in variable %i in reverse order, please check!", i));
-      return val;
-    }
-  }
-  val=GetSum(0,binMin,binMax);
-
-  return val;
-
-} 
-//_____________________________________________________________________
-Double_t AliCFVGrid::GetIntegral(Double_t *varMin, Double_t* varMax ) const 
-{
-  //
-  // Get Integral in a range (extremes included)
-  //
-
-  Int_t *indexMin=new Int_t[fNVar];
-  Int_t *indexMax=new Int_t[fNVar];
-
-  //Find out the min and max bins
-
-  for(Int_t i=0;i<fNVar;i++){
-    Double_t xmin=varMin[i]; // the min values  
-    Double_t xmax=varMax[i]; // the min values  
-    Int_t nbins=fNVarBins[i]+1;
-    Double_t *bins=new Double_t[nbins];
-    for(Int_t ibin =0;ibin<nbins;ibin++){
-     bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
-    }
-    indexMin[i] = TMath::BinarySearch(nbins,bins,xmin);
-    indexMax[i] = TMath::BinarySearch(nbins,bins,xmax);
-    delete [] bins;
-  }
-
-  //move to the TH/THnSparse convention in N-dim bin numbering 
-  for(Int_t i=0;i<fNVar;i++){
-    indexMin[i]+=1;
-    indexMax[i]+=1;
-  }
-
-  Double_t val=GetIntegral(indexMin,indexMax);
-
-  delete [] indexMin;
-  delete [] indexMax;
-
-  return val;
-} 
-
-//_____________________________________________________________________
-Double_t AliCFVGrid::GetSum(Int_t ivar, Int_t *binMin, Int_t* binMax) const 
-{
-  //
-  // recursively add over nested loops.... 
-  //
-  static Double_t val;
-  if(ivar==0)val=0.;
-  for(Int_t ibin=binMin[ivar]-1;ibin<=binMax[ivar]-1;ibin++){
-  //-1 is to move from TH/ThnSparse N-dim bin convention to one in AliCFFrame
-    fIndex[ivar]=ibin;
-    if(ivar<fNVar-1) {
-      val=GetSum(ivar+1,binMin,binMax);
-    }
-    else {
-      Int_t iel=GetBinIndex(fIndex);
-      val+=GetElement(iel);
-    }
-  }
-
-  return val;
-}
-
-//____________________________________________________________________
-Long64_t AliCFVGrid::Merge(TCollection* list)
-{
-  // Merge a list of AliCF grids 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;
-  
-  Int_t count = 0;
-  while ((obj = iter->Next())) {
-    AliCFVGrid* entry = dynamic_cast<AliCFVGrid*> (obj);
-    if (entry == 0) 
-      continue;
-    this->Add(entry);
-    count++;
-  }
-
-  return count+1;
-}
-
-//____________________________________________________________________
-void AliCFVGrid::GetScaledValues(Double_t *fact, Double_t *in, Double_t *out) const{
-  //
-  // scale input *in and it error by (positive) fact (with error)
-  // and erite it to *out
-  //
-    out[0]=in[0]*fact[0];
-    out[1]=TMath::Sqrt(in[1]*in[1]/in[0]/in[0]
-                      +fact[1]*fact[1]/fact[0]/fact[0])*out[0];
-    
-}
diff --git a/CORRFW/AliCFVGrid.h b/CORRFW/AliCFVGrid.h
deleted file mode 100755 (executable)
index 90d82cd..0000000
+++ /dev/null
@@ -1,103 +0,0 @@
-#ifndef ALICFVGRID_H
-#define ALICFVGRID_H
-//--------------------------------------------------------------------//
-//                                                                    //
-// AliCFGrid.cxx Class                                                //
-// Just an interface to handle both AliCFGrid and AliCFGridSparse     //
-// implementations                                                    //
-//                                                                    //
-//--------------------------------------------------------------------//
-
-#include "AliCFFrame.h"
-
-class TCollection;
-class TH1D;
-class TH2D;
-class TH3D;
-
-class AliCFVGrid : public AliCFFrame
-{
- public:
-  AliCFVGrid();
-  AliCFVGrid(const AliCFVGrid & c);
-  AliCFVGrid(const Char_t* name,const Char_t* title);
-  AliCFVGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t* nBinIn, const Double_t  *binLimitsIn=0);
-  
-  virtual ~AliCFVGrid();
-  AliCFVGrid& operator=(const AliCFVGrid& corr);
-  //abstract stuff
-
-  virtual void  Fill(Double_t *var, Double_t weight=1.) = 0;
-
-  virtual Float_t GetOverFlows(Int_t var) const = 0;
-  virtual Float_t GetUnderFlows(Int_t var)const = 0;
-  virtual Float_t GetEntries()const = 0 ;
-
-  virtual Float_t GetElement(Int_t iel)const = 0; 
-  virtual Float_t GetElement(Int_t *bin)const = 0; 
-  virtual Float_t GetElement(Double_t *var)const = 0; 
-  virtual Float_t GetElementError(Int_t iel)const = 0; 
-  virtual Float_t GetElementError(Int_t *bin)const = 0; 
-  virtual Float_t GetElementError(Double_t *var)const = 0; 
-
-  virtual void SetElement(Int_t iel, Float_t val) = 0; 
-  virtual void SetElement(Int_t *bin, Float_t val) = 0; 
-  virtual void SetElement(Double_t *var, Float_t val) = 0; 
-  virtual void SetElementError(Int_t iel, Float_t val) = 0; 
-  virtual void SetElementError(Int_t *bin, Float_t val) = 0; 
-  virtual void SetElementError(Double_t *var, Float_t val) = 0; 
-
-  virtual TH1D*       Project( Int_t ivar) const = 0;
-  virtual TH2D*       Project( Int_t ivar1, Int_t ivar2) const = 0;
-  virtual TH3D*       Project( Int_t ivar1, Int_t ivar2,Int_t ivar3) const = 0;
-  virtual AliCFVGrid* Project( Int_t nVars, Int_t* vars, Double_t* varMin, Double_t* varMax) const = 0;
-  virtual TH1D* Slice(Int_t ivar, Double_t *varMin, Double_t *varMax) const = 0;
-  virtual TH2D* Slice(Int_t ivar1, Int_t ivar2, Double_t *varMin, Double_t *varMax) const = 0;
-  virtual TH3D* Slice(Int_t ivar1, Int_t ivar2, Int_t ivar3, Double_t *varMin, Double_t *varMax) const = 0;
-
-  virtual void  UseAxisRange(Bool_t b) const = 0 ;
-
-  //basic operations
-  virtual void SumW2()=0;
-  virtual void Add(const AliCFVGrid* aGrid, Double_t c=1.) = 0;
-  virtual void Add(const AliCFVGrid* aGrid1 ,const AliCFVGrid* aGrid2, Double_t c1=1.,Double_t c2=1.) = 0;
-  virtual void Multiply(const AliCFVGrid* aGrid, Double_t c=1.) = 0;
-  virtual void Multiply(const AliCFVGrid* aGrid1,const AliCFVGrid* aGrid2, Double_t c1=1.,Double_t c2=1.) = 0;
-  virtual void Divide(const AliCFVGrid* aGrid, Double_t c=1.) = 0;
-  virtual void Divide(const AliCFVGrid* aGrid1, const AliCFVGrid* aGrid2, Double_t c1=1., Double_t c2=1.,Option_t *option=0) = 0;
-  virtual void Rebin(const Int_t* group) = 0;
-
-
-
-  //implemented in AliCFVGrid
-
-  virtual void Scale(Int_t iel, Double_t *fact); 
-  virtual void Scale(Int_t* bin, Double_t *fact); 
-  virtual void Scale(Double_t* var, Double_t *fact); 
-  virtual void Scale(Double_t *fact); // To normalize MC to int lumi, for ex. 
-  virtual Int_t    GetEmptyBins()const;
-  virtual Int_t    CheckStats(Double_t thr) const;
-  virtual Int_t    GetSumW2()const {return fSumW2;};
-  virtual Int_t    GetEmptyBins(Double_t *varMin,Double_t *varMax) const;
-  virtual Double_t GetIntegral() const;
-  virtual Double_t GetIntegral(Int_t *binMin,Int_t *binMax) const;
-  virtual Double_t GetIntegral(Double_t *varMin,Double_t *varMax) const;
-  virtual Long64_t Merge(TCollection* list);
-  virtual void Copy(TObject& c) const;
-
- protected:
-
-  Double_t GetSum(Int_t ivar, Int_t *binMin, Int_t* binMax) const; 
-  void GetScaledValues(Double_t *fact, Double_t *in, Double_t *out) const;
-  //'hidden dimensions' when performing projections, 
-  // default is kTRUE. please notice that 
-  // if you you use AliCFGrid instead of AliCFGridSparse, 
-  // only option kTRUE is actually available  
-  Bool_t   fSumW2;//flag to check if calculation of squared weights enabled
-   
-  ClassDef(AliCFVGrid,3);
-};
-    
-#endif
-
index 09853cb..3569459 100644 (file)
@@ -2,8 +2,6 @@
 
 set(SRCS
 AliCFFrame.cxx
-AliCFVGrid.cxx
-AliCFGrid.cxx
 AliCFGridSparse.cxx
 AliCFEffGrid.cxx
 AliCFDataGrid.cxx
index 75c4ee4..a589310 100644 (file)
@@ -5,8 +5,6 @@
 #pragma link off all functions;
 
 #pragma link C++ class  AliCFFrame+;
-#pragma link C++ class  AliCFVGrid+;
-#pragma link C++ class  AliCFGrid+;
 #pragma link C++ class  AliCFGridSparse+;
 #pragma link C++ class  AliCFEffGrid+;
 #pragma link C++ class  AliCFDataGrid+;
index 3535b14..7be68e3 100644 (file)
@@ -1,8 +1,6 @@
 #-*- Mode: Makefile -*-
 
 SRCS = AliCFFrame.cxx \
-       AliCFVGrid.cxx \
-       AliCFGrid.cxx \
        AliCFGridSparse.cxx \
        AliCFEffGrid.cxx \
        AliCFDataGrid.cxx \
index 5e29391..983326c 100644 (file)
@@ -48,11 +48,13 @@ Bool_t AliCFRsnTask(
     //here put your input data path
     if (readAOD) {
       analysisChain = new TChain("aodTree");
-      analysisChain->Add("AliAOD.root");
+      analysisChain->Add("your_data_path/001/AliAOD.root");
+      analysisChain->Add("your_data_path/002/AliAOD.root");
     }
     else {
       analysisChain = new TChain("esdTree");
-      analysisChain->Add("AliESDs.root");
+      analysisChain->Add("your_data_path/001/AliESDs.root");
+      analysisChain->Add("your_data_path/002/AliESDs.root");
     }
   }
   
index 10cc2be..ee126d6 100644 (file)
@@ -55,11 +55,13 @@ Bool_t AliCFSingleTrackTask(
 
     if (readAOD) {
       analysisChain = new TChain("aodTree");
-      analysisChain->Add("AliAOD.root");
+      analysisChain->Add("your_data_path/001/AliAOD.root");
+      analysisChain->Add("your_data_path/002/AliAOD.root");
     }
     else {
       analysisChain = new TChain("esdTree");
-      analysisChain->Add("AliESDs.root");
+      analysisChain->Add("your_data_path/001/AliESDs.root");
+      analysisChain->Add("your_data_path/002/AliESDs.root");
     }
   }
   
@@ -94,13 +96,25 @@ Bool_t AliCFSingleTrackTask(
   //setting the bin limits
   container -> SetBinLimits(ipt,binLim1);
   container -> SetBinLimits(iy,binLim2);
-
+  container -> SetVarTitle(ipt,"pt");
+  container -> SetVarTitle(iy, "y");
+  container -> SetStepTitle(0, "generated");
+  container -> SetStepTitle(1, "in acceptance");
+  container -> SetStepTitle(2, "reconstructed");
+  container -> SetStepTitle(3, "after PID");
 
   // SET TLIST FOR QA HISTOS
   TList* qaList = new TList();
 
   //CREATE THE  CUTS -----------------------------------------------
 
+  //Event-level cuts:
+  AliCFEventRecCuts* evtRecCuts = new AliCFEventRecCuts("evtRecCuts","Rec-event cuts");
+//   evtRecCuts->SetUseTPCVertex();
+//   evtRecCuts->SetRequireVtxCuts(kTRUE);
+//   evtRecCuts->SetVertexNContributors(-2,5);
+  evtRecCuts->SetQAOn(qaList);
+
   // Gen-Level kinematic cuts
   AliCFTrackKineCuts *mcKineCuts = new AliCFTrackKineCuts("mcKineCuts","MC-level kinematic cuts");
   mcKineCuts->SetPtRange(ptmin,ptmax);
@@ -111,7 +125,7 @@ Bool_t AliCFSingleTrackTask(
   //Particle-Level cuts:  
   AliCFParticleGenCuts* mcGenCuts = new AliCFParticleGenCuts("mcGenCuts","MC particle generation cuts");
   mcGenCuts->SetRequireIsPrimary();
-  mcGenCuts->SetRequirePdgCode(PDG);
+  mcGenCuts->SetRequirePdgCode(PDG,/*absolute=*/kTRUE);
   mcGenCuts->SetQAOn(qaList);
 
   //Acceptance Cuts
@@ -128,8 +142,11 @@ Bool_t AliCFSingleTrackTask(
   recKineCuts->SetQAOn(qaList);
 
   AliCFTrackQualityCuts *recQualityCuts = new AliCFTrackQualityCuts("recQualityCuts","rec-level quality cuts");
-  if (!readAOD)       recQualityCuts->SetMinNClusterTPC(minclustersTPC);
-  if (!readTPCTracks) recQualityCuts->SetStatus(AliESDtrack::kITSrefit);
+  if (!readAOD)       {
+//     recQualityCuts->SetMinNClusterTRD(0);
+//     recQualityCuts->SetMaxChi2PerClusterTRD(10.);
+  }
+  recQualityCuts->SetStatus(AliESDtrack::kTPCrefit);
   recQualityCuts->SetQAOn(qaList);
 
   AliCFTrackIsPrimaryCuts *recIsPrimaryCuts = new AliCFTrackIsPrimaryCuts("recIsPrimaryCuts","rec-level isPrimary cuts");
@@ -163,6 +180,10 @@ Bool_t AliCFSingleTrackTask(
   }
   cutPID->SetQAOn(qaList);
 
+  printf("CREATE EVENT LEVEL CUTS\n");
+  TObjArray* evtList = new TObjArray(0) ;
+//   evtList->AddLast(evtRecCuts);
+  
   printf("CREATE MC KINE CUTS\n");
   TObjArray* mcList = new TObjArray(0) ;
   mcList->AddLast(mcKineCuts);
@@ -185,11 +206,15 @@ Bool_t AliCFSingleTrackTask(
   //CREATE THE INTERFACE TO CORRECTION FRAMEWORK USED IN THE TASK
   printf("CREATE INTERFACE AND CUTS\n");
   AliCFManager* man = new AliCFManager() ;
-  man->SetParticleContainer     (container);
-  man->SetParticleCutsList(AliCFManager::kPartGenCuts,mcList);
-  man->SetParticleCutsList(AliCFManager::kPartAccCuts,accList);
-  man->SetParticleCutsList(AliCFManager::kPartRecCuts,recList);
-  man->SetParticleCutsList(AliCFManager::kPartSelCuts,fPIDCutList);
+
+  man->SetNStepEvent(1);
+  man->SetEventCutsList(0,evtList);
+
+  man->SetParticleContainer(container);
+  man->SetParticleCutsList(0,mcList);
+  man->SetParticleCutsList(1,accList);
+  man->SetParticleCutsList(2,recList);
+  man->SetParticleCutsList(3,fPIDCutList);
 
 
   //CREATE THE TASK
@@ -269,5 +294,5 @@ void Load() {
 
   //compile online the task class
   gSystem->SetIncludePath("-I. -I$ALICE_ROOT/include -I$ROOTSYS/include");
-  gROOT->LoadMacro("./AliCFSingleTrackTask.cxx+");
+  gROOT->LoadMacro("./AliCFSingleTrackTask.cxx++g");
 }
index 8507d87..c30ffee 100644 (file)
@@ -54,8 +54,8 @@ class AliCFTaskForUnfolding : public AliAnalysisTaskSE {
 
   // Histograms
   //Number of events
-  TH1I  *fHistEventsProcessed; // simple histo for monitoring the number of events processed
-  THnSparse* fCorrelation;          //response matrix for unfolding  
+  TH1I       *fHistEventsProcessed; // simple histo for monitoring the number of events processed
+  THnSparse  *fCorrelation;         //response matrix for unfolding  
   ClassDef(AliCFTaskForUnfolding,0);
 };
 
index f57d188..d203eb2 100644 (file)
@@ -52,11 +52,13 @@ Bool_t AliCFV0Task(
     //here put your input data path
     if (readAOD) {
       analysisChain = new TChain("aodTree");
-      analysisChain->Add("AliAOD.root");
+      analysisChain->Add("your_data_path/001/AliAOD.root");
+      analysisChain->Add("your_data_path/002/AliAOD.root");
     }
     else {
       analysisChain = new TChain("esdTree");
-      analysisChain->Add("AliESDs.root");
+      analysisChain->Add("your_data_path/001/AliESDs.root");
+      analysisChain->Add("your_data_path/002/AliESDs.root");
     }
   }
   
diff --git a/CORRFW/test/muons/AliCFMuonResTask1.C b/CORRFW/test/muons/AliCFMuonResTask1.C
deleted file mode 100644 (file)
index 6fc6991..0000000
+++ /dev/null
@@ -1,282 +0,0 @@
-// DEFINITION OF A FEW CONSTANTS
-
-const Double_t nevtmin= 1;
-const Double_t nevtmax = 15000;
-
-// Muons 
-const Double_t ymin  = -4.0 ;
-const Double_t ymax  =  -2.5 ;
-
-const Double_t phimin = -180;
-const Double_t phimax = 180;
-
-// Resonance
-const Int_t    PDG = 443;
-
-const Double_t ptmin =  0.0 ;
-const Double_t ptmax =  30 ;
-const Double_t pmin =  0.0 ;
-const Double_t pmax =  700 ;
-const Int_t    charge  = 0 ;
-const Double_t mmin =  0.1 ;
-const Double_t mmax =  6 ;
-const Double_t mymin =  -5 ;
-const Double_t mymax =  -1.5 ;
-
-//----------------------------------------------------
-
-Bool_t AliCFMuonResTask1(
-                           const Bool_t useGrid = 0,
-                           const Bool_t readAOD = 0,
-                           const char * kTagXMLFile="wn.xml" // XML file containing tags
-                           )
-{
-  
-  TBenchmark benchmark;
-  benchmark.Start("AliMuonResTask1");
-
-  AliLog::SetGlobalDebugLevel(0);
-
-  Load() ; // load the required libraries
-
-  TChain * analysisChain ;
-
-///// INPUT
-
-  if (useGrid) { // data located on AliEn
-    TGrid::Connect("alien://") ;    //  Create an AliRunTagCuts and an AliEventTagCuts Object 
-                                    //  and impose some selection criteria
-    AliRunTagCuts      *runCuts   = new AliRunTagCuts(); 
-    AliEventTagCuts    *eventCuts = new AliEventTagCuts(); 
-    AliLHCTagCuts      *lhcCuts   = new AliLHCTagCuts(); 
-    AliDetectorTagCuts *detCuts   = new AliDetectorTagCuts(); 
-    eventCuts->SetMultiplicityRange(0,2000);
-
-    //  Create an AliTagAnalysis Object and chain the tags
-    AliTagAnalysis   *tagAna = new AliTagAnalysis(); 
-    if (readAOD) tagAna->SetType("AOD");  // for aliroot > v4-05
-    else         tagAna->SetType("ESD");  // for aliroot > v4-05
-    TAlienCollection *coll   = TAlienCollection::Open(kTagXMLFile); 
-    TGridResult      *tagResult = coll->GetGridResult("",0,0);
-    tagResult->Print();
-    tagAna->ChainGridTags(tagResult);
-
-    // Create a new esd chain and assign the chain that is returned by querying the tags
-    analysisChain = tagAna->QueryTags(runCuts,lhcCuts,detCuts,eventCuts); 
-  }
-
-  else {// local data
-    // here put your input data path
-    printf("\n\nRunning on local file, please check the path\n\n");
-
-    if (readAOD) {
-      analysisChain = new TChain("aodTree");
-      analysisChain->Add("AliAOD.root");
-    }
-    else {
-      analysisChain = new TChain("esdTree");
-      analysisChain->Add("/scratch/lopez/PDC08jpsi/run2-300/AliESDs.root");
-      analysisChain->Add("/scratch/lopez/PDC08jpsi/run3-1000/AliESDs.root");
-      analysisChain->Add("/scratch/lopez/PDC08jpsi/run4-1000/AliESDs.root");
-      analysisChain->Add("/scratch/lopez/PDC08jpsi/run5-1000/AliESDs.root");
-      analysisChain->Add("/scratch/lopez/PDC08jpsi/run7-1000/AliESDs.root");
-      analysisChain->Add("/scratch/lopez/PDC08jpsi/run8-1000/AliESDs.root");
-      analysisChain->Add("/scratch/lopez/PDC08jpsi/run9-1000/AliESDs.root");
-      analysisChain->Add("/scratch/lopez/PDC08jpsi/run10-1000/AliESDs.root");
-      analysisChain->Add("/scratch/lopez/PDC08jpsi/run11-1000/AliESDs.root");
-      analysisChain->Add("/scratch/lopez/PDC08jpsi/run12-1000/AliESDs.root");
-      analysisChain->Add("/scratch/lopez/PDC08jpsi/run13-1000/AliESDs.root");
-   }
-  }
-  
-///// END INPUT
-
-
-  Info("AliCFMuonResTask1",Form("CHAIN HAS %d ENTRIES",(Int_t)analysisChain->GetEntries()));
-
-  // CONTAINER DEFINITION
-  Info("AliCFMuonResTask1","SETUP CONTAINER");
-  
-  // The sensitive variables (9 in this example), their indices
-  UInt_t nevt  = 0;
-  UInt_t y1  = 1;
-  UInt_t phi1  = 2;
-  UInt_t y2  = 3;
-  UInt_t phi2  = 4;
-  UInt_t imass  = 5;
-  UInt_t y  = 6;
-  UInt_t pt = 7;
-  UInt_t p = 8;
-
-
-  // Setting up the container grid
-  UInt_t nstep = 2 ; //number of selection steps : MC and ESD 
-  const Int_t nvar   = 9 ;     //number of variables on the grid
-  const Int_t nbin1  = nevtmax ;  
-  const Int_t nbin2  = 100 ;  
-  const Int_t nbin3  = 360 ;  
-  const Int_t nbin4  = 100 ;  
-  const Int_t nbin5  = 360 ;  
-  const Int_t nbin6  = 100 ;  
-  const Int_t nbin7  = 100 ;  
-  const Int_t nbin8  = 100 ;  
-  const Int_t nbin9  = 100 ;  
-
-  // arrays for the number of bins in each dimension
-  Int_t iBin[nvar];
-  iBin[0]=nbin1;
-  iBin[1]=nbin2;
-  iBin[2]=nbin3;
-  iBin[3]=nbin4;
-  iBin[4]=nbin5;
-  iBin[5]=nbin6;
-  iBin[6]=nbin7;
-  iBin[7]=nbin8;
-  iBin[8]=nbin9;
-
-  // arrays for lower bounds :
-  Double_t *binLim1=new Double_t[nbin1+1];
-  Double_t *binLim2=new Double_t[nbin2+1];
-  Double_t *binLim3=new Double_t[nbin3+1];
-  Double_t *binLim4=new Double_t[nbin4+1];
-  Double_t *binLim5=new Double_t[nbin5+1];
-  Double_t *binLim6=new Double_t[nbin6+1];
-  Double_t *binLim7=new Double_t[nbin7+1];
-  Double_t *binLim8=new Double_t[nbin8+1];
-  Double_t *binLim9=new Double_t[nbin9+1];
-
-  // values for bin lower bounds
-  for(Int_t i=0; i<=nbin1; i++) binLim1[i]=(Double_t)nevtmin  + (nevtmax-nevtmin)  /nbin1*(Double_t)i ;
-  for(Int_t i=0; i<=nbin2; i++) binLim2[i]=(Double_t)ymin  + (ymax-ymin)  /nbin2*(Double_t)i ;
-  for(Int_t i=0; i<=nbin3; i++) binLim3[i]=(Double_t)phimin  + (phimax-phimin)  /nbin3*(Double_t)i ;
-  for(Int_t i=0; i<=nbin4; i++) binLim4[i]=(Double_t)ymin  + (ymax-ymin)  /nbin4*(Double_t)i ;
-  for(Int_t i=0; i<=nbin5; i++) binLim5[i]=(Double_t)phimin  + (phimax-phimin)  /nbin5*(Double_t)i ;
-  for(Int_t i=0; i<=nbin6; i++) binLim6[i]=(Double_t)mmin  + (mmax-mmin)  /nbin6*(Double_t)i ;
-  for(Int_t i=0; i<=nbin7; i++) binLim7[i]=(Double_t)mymin  + (mymax-mymin)  /nbin7*(Double_t)i ;
-  for(Int_t i=0; i<=nbin8; i++) binLim8[i]=(Double_t)ptmin + (ptmax-ptmin)/nbin8*(Double_t)i ; 
-  for(Int_t i=0; i<=nbin9; i++) binLim9[i]=(Double_t)pmin + (pmax-pmin)/nbin9*(Double_t)i ; 
-
-  // one container  of 2 steps (MC and ESD) with 9 variables
-  AliCFContainer* container = new AliCFContainer("container","container for tracks",nstep,nvar,iBin);
-  // setting the bin limits
-  container -> SetBinLimits(nevt,binLim1);
-  container -> SetBinLimits(y1,binLim2);
-  container -> SetBinLimits(phi1,binLim3);
-  container -> SetBinLimits(y2,binLim4);
-  container -> SetBinLimits(phi2,binLim5);
-  container -> SetBinLimits(imass,binLim6);
-  container -> SetBinLimits(y,binLim7);
-  container -> SetBinLimits(pt,binLim8);
-  container -> SetBinLimits(p,binLim9);
-
-  // Set list
-  TList* qaList = new TList();
-
-  //CREATE THE CUTS
-  // Choice of the Resonance
-  AliCFParticleGenCuts* mcGenCuts = new AliCFParticleGenCuts("mcGenCuts","MC particle generation cuts");
-  mcGenCuts->SetRequirePdgCode(PDG);
-  mcGenCuts->SetQAOn(qaList);
-
-  // Set a pt range of the resonance
-  AliCFTrackKineCuts *mcKineCuts = new AliCFTrackKineCuts("mcKineCuts","MC-level kinematic cuts");
-  mcKineCuts->SetChargeMC(charge);
-  mcKineCuts->SetPtRange(ptmin,ptmax);
-  mcKineCuts->SetQAOn(qaList);
-
-  // Create and fill the list associated 
-  TObjArray* mcList = new TObjArray(0) ;
-  mcList->AddLast(mcKineCuts);
-  mcList->AddLast(mcGenCuts);
-
-  // kinematic cuts on muons rapidity 
-  AliCFTrackKineCuts *recKineCuts = new AliCFTrackKineCuts("recKineCuts","rec-level kine cuts");
-  recKineCuts->SetRapidityRange(ymin,ymax);
-  recKineCuts->SetQAOn(qaList);
-  TObjArray* recList = new TObjArray(0) ;
-  recList->AddLast(recKineCuts);
-
-  // CREATE THE INTERFACE TO CORRECTION FRAMEWORK USED IN THE TASK
-
-   printf("CREATE INTERFACE AND CUTS\n");
-  AliCFManager* man = new AliCFManager() ;
-  man->SetParticleContainer     (container);
-
-  man->SetParticleCutsList(AliCFManager::kPartGenCuts,mcList);
-  man->SetParticleCutsList(AliCFManager::kPartAccCuts,recList);
-
-  //CREATE THE TASK
-  printf("CREATE TASK\n");
-  // create the task
-  AliCFMuonResTask1 *task = new AliCFMuonResTask1("AliMuonResTask1");
-  task->SetCFManager(man); //here is set the CF manager
-  task->SetQAList(qaList);
-  if (readAOD)       task->SetReadAODData() ;
-
-  //SETUP THE ANALYSIS MANAGER TO READ INPUT CHAIN AND WRITE DESIRED OUTPUTS
-  printf("CREATE ANALYSIS MANAGER\n");
-  // Make the analysis manager
-  AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
-
-  if (useGrid) mgr->SetAnalysisType(AliAnalysisManager::kGridAnalysis);
-  else mgr->SetAnalysisType(AliAnalysisManager::kLocalAnalysis);
-
-
-  AliMCEventHandler*  mcHandler = new AliMCEventHandler();
-  mgr->SetMCtruthEventHandler(mcHandler);
-  AliInputEventHandler* dataHandler ;
-  
-  if   (readAOD) dataHandler = new AliAODInputHandler();
-  else           dataHandler = new AliESDInputHandler();
-  mgr->SetInputEventHandler(dataHandler);
-
-  // Create and connect containers for input/output
-
-  // input data 
-  AliAnalysisDataContainer *cinput0  = mgr->CreateContainer("cchain0",TChain::Class(),AliAnalysisManager::kInputContainer);
-
-  // output data
-  Char_t file[256];
-  sprintf(file,"CFMuonResTask1.root");
-  printf("Analysis output in %s \n",file);
-
-  // output TH1I for event counting
-  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("chist0", TH1I::Class(),AliAnalysisManager::kOutputContainer,file);
-  // output Correction Framework Container (for acceptance & efficiency calculations)
-  AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("ccontainer0", AliCFContainer::Class(),AliAnalysisManager::kOutputContainer,file);
-
-  cinput0->SetData(analysisChain);
-  mgr->AddTask(task);
-
-  mgr->ConnectInput(task,0,mgr->GetCommonInputContainer());
-
-  mgr->ConnectOutput(task,1,coutput1);
-  mgr->ConnectOutput(task,2,coutput2);
-
-  printf("READY TO RUN\n");
-  //RUN !!!
-  if (mgr->InitAnalysis()) {
-    mgr->PrintStatus();
-    mgr->StartAnalysis("local",analysisChain);
-  }
-
-  benchmark.Stop("AliMuonResTask1");
-  benchmark.Show("AliMuonResTask1");
-
-  return kTRUE ;
-}
-
-void Load() {
-
-  //load the required aliroot libraries
-  gSystem->Load("libANALYSIS") ;
-  gSystem->Load("libANALYSISalice") ;
-
-//  gSystem->Load("libCORRFW.so") ;
-  gSystem->Load("$ALICE_ROOT/lib/tgt_linux/libCORRFW.so") ;
-
-  //compile online the task class
-  gSystem->SetIncludePath("-I. -I$ALICE_ROOT/include -I$ROOTSYS/include");
-  gROOT->LoadMacro("./AliCFMuonResTask1.cxx+");
-}
diff --git a/CORRFW/test/muons/AliCFMuonResTask1.cxx b/CORRFW/test/muons/AliCFMuonResTask1.cxx
deleted file mode 100644 (file)
index 19f9147..0000000
+++ /dev/null
@@ -1,375 +0,0 @@
-/**************************************************************************\r
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
- *                                                                        *\r
- * Author: The ALICE Off-line Project.                                    *\r
- * Contributors are mentioned in the code where appropriate.              *\r
- *                                                                        *\r
- * Permission to use, copy, modify and distribute this software and its   *\r
- * documentation strictly for non-commercial purposes is hereby granted   *\r
- * without fee, provided that the above copyright notice appears in all   *\r
- * copies and that both the copyright notice and this permission notice   *\r
- * appear in the supporting documentation. The authors make no claims     *\r
- * about the suitability of this software for any purpose. It is          *\r
- * provided "as is" without express or implied warranty.                  *\r
- **************************************************************************/\r
-\r
-//-----------------------------------------------------------------------\r
-// Example of task (running locally, on AliEn and CAF),\r
-// which provides standard way of calculating acceptance and efficiency\r
-// between different steps of the procedure.\r
-// The ouptut of the task is a AliCFContainer from which the efficiencies\r
-// can be calculated\r
-//-----------------------------------------------------------------------\r
-// Author : R. Vernet, Consorzio Cometa - Catania (it)\r
-//-----------------------------------------------------------------------\r
-// Modification done by X. Lopez - LPC Clermont (fr)\r
-//-----------------------------------------------------------------------\r
-\r
-\r
-#ifndef ALICFMUONRESTASK1_CXX\r
-#define ALICFMUONRESTASK1_CXX\r
-\r
-#include "AliCFMuonResTask1.h"\r
-#include "AliHeader.h"\r
-#include "AliESDHeader.h"\r
-#include "AliStack.h"\r
-#include "TParticle.h"\r
-#include "TH1I.h"\r
-#include "AliMCEvent.h"\r
-#include "AliAnalysisManager.h"\r
-#include "AliESDEvent.h"\r
-#include "AliAODEvent.h"\r
-#include "AliCFManager.h"\r
-#include "AliCFCutBase.h"\r
-#include "AliCFContainer.h"\r
-#include "TChain.h"\r
-#include "AliESDtrack.h"\r
-#include "AliLog.h"\r
-#include "AliESDMuonTrack.h"\r
-#include "AliESDtrack.h"\r
-#include "AliESDInputHandler.h"\r
-#include "TCanvas.h"\r
-\r
-ClassImp(AliCFMuonResTask1)\r
-\r
-//__________________________________________________________________________\r
-AliCFMuonResTask1::AliCFMuonResTask1() :\r
-  fReadAODData(0),\r
-  fCFManager(0x0),\r
-  fQAHistList(0x0),\r
-  fHistEventsProcessed(0x0),\r
-  fNevt(0)\r
-{\r
-  //\r
-  //Default ctor\r
-  //\r
-}\r
-//___________________________________________________________________________\r
-AliCFMuonResTask1::AliCFMuonResTask1(const Char_t* name) :\r
-  AliAnalysisTaskSE(name),\r
-  fReadAODData(0),\r
-  fCFManager(0x0),\r
-  fQAHistList(0x0),\r
-  fHistEventsProcessed(0x0),\r
-  fNevt(0)\r
-{\r
-  //\r
-  // Constructor. Initialization of Inputs and Outputs\r
-  //\r
-  Info("AliCFMuonResTask1","Calling Constructor");\r
-\r
-  fHistEventsProcessed = new TH1I("fHistEventsProcessed","",1,0,1) ;\r
-\r
-  DefineOutput(1,TH1I::Class());\r
-  DefineOutput(2,AliCFContainer::Class());\r
-\r
-}\r
-\r
-//___________________________________________________________________________\r
-AliCFMuonResTask1& AliCFMuonResTask1::operator=(const AliCFMuonResTask1& c) \r
-{\r
-  //\r
-  // Assignment operator\r
-  //\r
-  if (this!=&c) {\r
-    AliAnalysisTaskSE::operator=(c) ;\r
-    fReadAODData = c.fReadAODData ;\r
-    fCFManager  = c.fCFManager;\r
-    fQAHistList = c.fQAHistList ;\r
-    fHistEventsProcessed = c.fHistEventsProcessed;\r
-    fNevt = c.fNevt ;\r
-  }\r
-  return *this;\r
-}\r
-\r
-//___________________________________________________________________________\r
-AliCFMuonResTask1::AliCFMuonResTask1(const AliCFMuonResTask1& c) :\r
-  AliAnalysisTaskSE(c),\r
-  fReadAODData(c.fReadAODData),\r
-  fCFManager(c.fCFManager),\r
-  fQAHistList(c.fQAHistList),\r
-  fHistEventsProcessed(c.fHistEventsProcessed),\r
-  fNevt(c.fNevt) \r
-{\r
-  //\r
-  // Copy Constructor\r
-  //\r
-}\r
-\r
-//___________________________________________________________________________\r
-AliCFMuonResTask1::~AliCFMuonResTask1() {\r
-  //\r
-  //destructor\r
-  //\r
-  Info("~AliCFMuonResTask1","Calling Destructor");\r
-  if (fCFManager)           delete fCFManager ;\r
-  if (fHistEventsProcessed) delete fHistEventsProcessed ;\r
-  if (fQAHistList) {fQAHistList->Clear(); delete fQAHistList;}\r
-}\r
-\r
-//_________________________________________________\r
-void AliCFMuonResTask1::UserExec(Option_t *)\r
-{\r
-  //\r
-  // Main loop function\r
-  // \r
-  \r
-  Info("UserExec","") ;\r
-  if (!fMCEvent) {\r
-    Error("UserExec","NO MC EVENT FOUND!");\r
-    return;\r
-  }\r
-\r
-  fNevt++; \r
-  Double_t containerInput[9] ;\r
\r
-////////\r
-//// MC\r
-//////// \r
-\r
-  fCFManager->SetEventInfo(fMCEvent);\r
-  AliStack* stack = fMCEvent->Stack();\r
-\r
-  // loop on the MC event\r
-  for (Int_t ipart=0; ipart<fMCEvent->GetNumberOfTracks(); ipart++) { \r
-    AliMCParticle *mcPart  = fMCEvent->GetTrack(ipart);\r
\r
-    TParticle *part = mcPart->Particle(); \r
-    TParticle *part0 = mcPart->Particle();\r
-    TParticle *part1 = mcPart->Particle();\r
\r
-    // Selection of the resonance\r
-    if (!fCFManager->CheckParticleCuts(AliCFManager::kPartGenCuts,mcPart)) continue;\r
-\r
-    // Mother kinematics\r
-    Float_t e = part->Energy();\r
-    Float_t pz = part->Pz();           \r
-    Float_t py = part->Py();\r
-    Float_t px = part->Px();\r
-    Float_t rapmc = Rap(e,pz);\r
-    Float_t mass = part->GetCalcMass();\r
-\r
-    // Decays kinematics\r
-\r
-    Int_t p0 = part->GetDaughter(0);\r
-    part0 = stack->Particle(p0); \r
-   // selection of the rapidity for first muon\r
-    AliMCParticle *mcpart0 = new AliMCParticle(part0);\r
-    if (!fCFManager->CheckParticleCuts(AliCFManager::kPartAccCuts,mcpart0)) continue;\r
-    Int_t pdg0 = part0->GetPdgCode();\r
-\r
-    Int_t p1 = part->GetDaughter(1);\r
-    part1 = stack->Particle(p1);\r
-   // selection of the rapidity for second muon\r
-    AliMCParticle *mcpart1 = new AliMCParticle(part1);\r
-    if (!fCFManager->CheckParticleCuts(AliCFManager::kPartAccCuts,mcpart1)) continue;\r
-    Int_t pdg1 = part1->GetPdgCode();\r
\r
-   // 0 mu- 1 mu+\r
-    Float_t e0, pz0, py0, px0, phi0, rapmc0;\r
-    Float_t e1, pz1, py1, px1, phi1, rapmc1;\r
-\r
-    // ordering sign: first = mu-\r
-    if(pdg0==13){\r
-       e0 = part0->Energy();\r
-       pz0 = part0->Pz();\r
-       py0 = part0->Py();\r
-       px0 = part0->Px();\r
-       phi0 = part0->Phi(); \r
-       phi0 = Phideg(phi0);    \r
-       rapmc0=Rap(e0,pz0);\r
-\r
-       e1 = part1->Energy();\r
-       pz1 = part1->Pz();\r
-       py1 = part1->Py();\r
-       px1 = part1->Px();\r
-       phi1 = part1->Phi();\r
-       phi1 = Phideg(phi1);\r
-       rapmc1=Rap(e1,pz1);\r
-    }\r
-    else{\r
-       if(pdg0==-13){\r
-           e1 = part0->Energy();\r
-           pz1 = part0->Pz();\r
-           py1 = part0->Py();\r
-           px1 = part0->Px();\r
-           phi1 = part0->Phi();\r
-           phi1 = Phideg(phi1);    \r
-           rapmc1=Rap(e1,pz1);\r
-           \r
-           e0 = part1->Energy();\r
-           pz0 = part1->Pz();\r
-           py0 = part1->Py();\r
-           px0 = part1->Px();\r
-           phi0 = part1->Phi();\r
-           phi0 = Phideg(phi0);\r
-           rapmc0=Rap(e0,pz0); \r
-       }\r
-    }\r
-    \r
-    if(pdg0==13 || pdg1==13) { \r
-\r
-       Float_t pmc = TMath::Sqrt((px0+px1)*(px0+px1)+(py0+py1)*(py0+py1)+\r
-                                  (pz0+pz1)*(pz0+pz1));\r
-       Float_t ptmc = TMath::Sqrt((px0+px1)*(px0+px1)+(py0+py1)*(py0+py1));\r
-       Float_t imassmc = Imass(e0,px0,py0,pz0,e1,px1,py1,pz1);\r
-       Float_t rapmc_check=Rap((e0+e1),(pz0+pz1));\r
-\r
-       containerInput[0] = fNevt ;   \r
-       containerInput[1] = rapmc0 ;   \r
-       containerInput[2] = phi0 ;   \r
-       containerInput[3] = rapmc1 ;   \r
-       containerInput[4] = phi1 ;   \r
-       containerInput[5] = imassmc ;   \r
-       containerInput[6] = rapmc ;   \r
-       containerInput[7] = ptmc;\r
-       containerInput[8] = pmc;        \r
-\r
-       // fill the container at the first step\r
-       fCFManager->GetParticleContainer()->Fill(containerInput,0);\r
-    }\r
-  }    \r
-\r
-////////\r
-//// ESD\r
-////////\r
-  \r
-  AliESDEvent *fESD; \r
-  AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*>\r
-      (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
-  fESD = esdH->GetEvent();\r
-  Int_t mult1 = fESD->GetNumberOfMuonTracks() ;\r
-\r
\r
-    for (Int_t j = 0; j<mult1; j++) { \r
-       AliESDMuonTrack* mu1 = new AliESDMuonTrack(*(fESD->GetMuonTrack(j)));\r
-       Float_t zr1 = mu1->Charge();\r
-// Select mu-\r
-       if(zr1<0){\r
-           Float_t pxr1 = mu1->Px();\r
-           Float_t pyr1 = mu1->Py();\r
-           Float_t pzr1 = mu1->Pz();\r
-           Float_t phir1 = mu1->Phi(); \r
-           phir1=Phideg(phir1);\r
-           Float_t er1 = mu1->E();\r
-           Float_t rap1=Rap(er1,pzr1);\r
-           // selection of the rapidity for first muon\r
-           if (!fCFManager->CheckParticleCuts(AliCFManager::kPartAccCuts,mu1)) continue;\r
-\r
-           for (Int_t jj = 0; jj<mult1; jj++) {\r
-               AliESDMuonTrack* mu2 = new AliESDMuonTrack(*(fESD->GetMuonTrack(jj)));\r
-               Float_t zr2 = mu2->Charge();\r
-// Select mu+\r
-               if(zr2>0 && jj !=j){\r
-                   Float_t pxr2 = mu2->Px();\r
-                   Float_t pyr2 = mu2->Py();\r
-                   Float_t pzr2 = mu2->Pz();\r
-                   Float_t phir2 = mu2->Phi();\r
-                   phir2 = Phideg(phir2);\r
-                   Float_t er2 = mu2->E();\r
-                   Float_t rap2=Rap(er2,pzr2);\r
-                   // selection of the rapidity for second muon\r
-                   if (!fCFManager->CheckParticleCuts(AliCFManager::kPartAccCuts,mu2)) continue;\r
-\r
-                   Float_t prec = TMath::Sqrt((pxr1+pxr2)*(pxr1+pxr2)+(pyr1+pyr2)*(pyr1+pyr2)+\r
-                                               (pzr1+pzr2)*(pzr1+pzr2));\r
-                   Float_t ptrec = TMath::Sqrt((pxr1+pxr2)*(pxr1+pxr2)+(pyr1+pyr2)*(pyr1+pyr2));\r
-                   Float_t raprec=Rap((er1+er2),(pzr1+pzr2));\r
-                   Float_t imassrec = Imass(er1,pxr1,pyr1,pzr1,er2,pxr2,pyr2,pzr2);\r
-\r
-                   containerInput[0] = fNevt ;   \r
-                   containerInput[1] = rap1 ;   \r
-                   containerInput[2] = phir1 ;   \r
-                   containerInput[3] = rap2 ;\r
-                   containerInput[4] = phir2 ;   \r
-                   containerInput[5] = imassrec ;   \r
-                   containerInput[6] = raprec ;   \r
-                   containerInput[7] = ptrec;\r
-                   containerInput[8] = prec;\r
-                   \r
-                   // fill the container at the second step\r
-                   fCFManager->GetParticleContainer()->Fill(containerInput,1);\r
-\r
-               }  // mu+ Selection\r
-           }      // second mu Loop\r
-       }          // mu- Selection\r
-    }        \r
\r
-//  ----------\r
-  fHistEventsProcessed->Fill(0);\r
-  PostData(1,fHistEventsProcessed) ;\r
-  PostData(2,fCFManager->GetParticleContainer()) ;\r
-}\r
-//________________________________________________________________________\r
-const Float_t AliCFMuonResTask1::Imass(Float_t e1, Float_t px1, Float_t py1, Float_t pz1,\r
-                                  Float_t e2, Float_t px2, Float_t py2, Float_t pz2) \r
-{\r
-// invariant mass calculation\r
-    Float_t imassrec = TMath::Sqrt((e1+e2)*(e1+e2)-((px1+px2)*(px1+px2)+\r
-                                    (py1+py2)*(py1+py2)+(pz1+pz2)*(pz1+pz2)));\r
-    return imassrec;\r
-}\r
-//________________________________________________________________________\r
-const Float_t AliCFMuonResTask1::Rap(Float_t e, Float_t pz) \r
-{\r
-// calculate rapidity\r
-    Float_t rap;\r
-    if(e!=pz){\r
-       rap = 0.5*TMath::Log((e+pz)/(e-pz));\r
-       return rap;\r
-    }\r
-    else{\r
-       rap = -200;\r
-       return rap;\r
-    }\r
-}\r
-//________________________________________________________________________\r
-const Float_t AliCFMuonResTask1::Phideg(Float_t phi) \r
-{\r
-// calculate Phi in range [-180,180] \r
-    Float_t phideg;\r
-    \r
-       phideg = phi-TMath::Pi();\r
-       phideg = phideg*57.296;\r
-       return phideg;\r
-}\r
-//________________________________________________________________________\r
-void AliCFMuonResTask1::Terminate(Option_t *) \r
-{\r
-  // draw result of the Invariant mass MC and ESD\r
-\r
-    AliCFContainer *cont = dynamic_cast<AliCFContainer*> (GetOutputData(2));   \r
-\r
-    TH1D *kmass = cont->ShowProjection(5,0);\r
-    TH1D *rmass = cont->ShowProjection(5,1);\r
-\r
-    TCanvas *c1 = new TCanvas("AliCFMuonResTask1","JPSI MC & ESD",10,10,510,510);\r
-    c1->Divide(1,2);\r
-    c1->cd(1);\r
-    kmass->Draw("HIST");\r
-    c1->cd(2);\r
-    rmass->Draw("HIST");\r
-}\r
-//________________________________________________________________________\r
-\r
-#endif\r
diff --git a/CORRFW/test/muons/AliCFMuonResTask1.h b/CORRFW/test/muons/AliCFMuonResTask1.h
deleted file mode 100644 (file)
index 357ca63..0000000
+++ /dev/null
@@ -1,73 +0,0 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-//-----------------------------------------------------------------------
-// Author : R. Vernet, Consorzio Cometa - Catania (it)
-//-----------------------------------------------------------------------
-// Modification done by X. Lopez - LPC Clermont (fr)
-//-----------------------------------------------------------------------
-
-#ifndef ALICFMUONRESTASK1_H
-#define ALICFMUONRESTASK1_H
-
-#include "AliAnalysisTaskSE.h"
-
-class TH1I;
-class TParticle ;
-class TFile ;
-class AliStack ;
-class AliCFManager;
-class AliESDtrack;
-class AliVParticle;
-
-class AliCFMuonResTask1 : public AliAnalysisTaskSE {
-  public:
-
-  AliCFMuonResTask1();
-  AliCFMuonResTask1(const Char_t* name);
-  AliCFMuonResTask1& operator= (const AliCFMuonResTask1& c);
-  AliCFMuonResTask1(const AliCFMuonResTask1& c);
-  virtual ~AliCFMuonResTask1();
-
-  // ANALYSIS FRAMEWORK STUFF to loop on data and fill output objects
-  void     UserExec(Option_t *option);
-  void     Terminate(Option_t *);
-   
-  // CORRECTION FRAMEWORK RELATED FUNCTIONS
-  void           SetCFManager(AliCFManager* const io) {fCFManager = io;}   // global correction manager
-  AliCFManager * GetCFManager() const {return fCFManager;}           // get corr manager
-  void           SetQAList(TList* const list) {fQAHistList = list;}
-
-  // Data types
-  Bool_t IsReadAODData()   const {return fReadAODData;}
-  void   SetReadAODData   (Bool_t flag=kTRUE) {fReadAODData=flag;}
-
- protected:
-  
-  Bool_t          fReadAODData ;   // flag for AOD/ESD input files
-  AliCFManager   *fCFManager   ;   // pointer to the CF manager
-  TList          *fQAHistList  ;   // list of QA histograms
-  TH1I           *fHistEventsProcessed; // simple histo for monitoring the number of events processed
-  Int_t           fNevt        ;   // event countor
-  
-  const Float_t Imass(Float_t e1, Float_t px1, Float_t py1, Float_t pz1,
-               Float_t e2, Float_t px2, Float_t py2, Float_t p2);
-  const  Float_t Rap(Float_t e, Float_t pz);
-  const Float_t Phideg(Float_t phi);
-  
-  ClassDef(AliCFMuonResTask1,1);
-};
-
-#endif
index e152417..b926176 100644 (file)
@@ -20,9 +20,8 @@ void testCFContainers(){
   gStyle->SetCanvasColor(0);
   gStyle->SetFrameFillColor(0);
 
-  gSystem->SetIncludePath("-I. -I$ALICE_ROOT/include  -I$ROOTSYS/include");
   gSystem->Load("libANALYSIS.so");
-  gSystem->Load("$ALICE_ROOT/CORRFW/libCORRFW.so") ;
+  gSystem->Load("libCORRFW.so") ;
  
   //Setting up the container grid... 
 
@@ -86,7 +85,7 @@ void testCFContainers(){
   //Start filling the mc and the data
 
   //data sample (1M tracks)
-  Int_t nev=1000000;
+  Int_t nev=100000;
   Int_t seed =1234;
   gRandom->SetSeed(seed);
   Double_t Value[nvar];
@@ -108,7 +107,7 @@ void testCFContainers(){
     }          
   }   
 
-// Save it to a file
+  //   Save it to a file
    cont->Save("container.root");
   //delete it
    delete cont;
@@ -119,25 +118,25 @@ void testCFContainers(){
 
   // Make some 1 & 2-D projections..
   // pt and vertex, generator and reconstructed level
-  TCanvas *cmc =new TCanvas("cmc","The  distributions",0,300,900,900);
-  cmc->Divide(2,2);
-  cmc->cd(1);
-  TH1D *hpt1a = data->ShowProjection(ipt, stepGen);
-  hpt1a->SetMinimum(0.01);
-  hpt1a->Draw();
-  cmc->cd(2);
-  TH1D *hpt1b = data->ShowProjection(ipt, stepRec);
-  hpt1b->SetMinimum(0.01);
-  hpt1b->Draw();
-  cmc->cd(3);
-  TH2D *hptvtx1a = data->ShowProjection(ipt,ivtx, stepGen);
-  hptvtx1a->SetMinimum(0.01);
-  hptvtx1a->Draw("lego");
-  cmc->cd(4);
-  TH2D *hptvtx1b = data->ShowProjection(ipt,ivtx, stepRec);
-  hptvtx1b->SetMinimum(0.01);
-  hptvtx1b->Draw("lego");
-  cmc->Print("data.gif");
+//   TCanvas *cmc =new TCanvas("cmc","The  distributions",0,300,900,900);
+//   cmc->Divide(2,2);
+//   cmc->cd(1);
+//   TH1D *hpt1a = data->ShowProjection(ipt, stepGen);
+//   hpt1a->SetMinimum(0.01);
+//   hpt1a->Draw();
+//   cmc->cd(2);
+//   TH1D *hpt1b = data->ShowProjection(ipt, stepRec);
+//   hpt1b->SetMinimum(0.01);
+//   hpt1b->Draw();
+//   cmc->cd(3);
+//   TH2D *hptvtx1a = data->ShowProjection(ipt,ivtx, stepGen);
+//   hptvtx1a->SetMinimum(0.01);
+//   hptvtx1a->Draw("lego");
+//   cmc->cd(4);
+//   TH2D *hptvtx1b = data->ShowProjection(ipt,ivtx, stepRec);
+//   hptvtx1b->SetMinimum(0.01);
+//   hptvtx1b->Draw("lego");
+//   cmc->Print("data.gif");
 
  
   //construct the efficiency grid from the data container 
index d5c7b38..0fed82f 100644 (file)
@@ -2,6 +2,7 @@
 void testSlice() {
   
   gStyle->SetPalette(1);
+  gStyle->SetOptStat(1111111);
 
   gSystem->Load("libANALYSIS");
   gSystem->Load("libCORRFW");
@@ -37,8 +38,8 @@ void testSlice() {
 
   Double_t epsilon=1.e-07;
 
-  Double_t varMin[2]={0.0 ,            0.0  };
-  Double_t varMax[2]={2.0 - epsilon ,  1.0  };
+  Double_t varMin[2]={0.0  ,  -1.0-epsilon  };
+  Double_t varMax[2]={8.0  ,   1.0-epsilon  };
 
 
   can->cd(iCan++);
@@ -73,6 +74,7 @@ void testSlice() {
   printf("====\n");
   printf("efficiency map properties\n");
   printf("nvar=%d\t nbins[0]=%d\n",eff->GetNVar(),eff->GetNBins(0));
+  printf("range = %d  -> %d\n",((AliCFGridSparse*)eff->GetNum())->GetGrid()->GetAxis(0)->GetFirst(),((AliCFGridSparse*)eff->GetNum())->GetGrid()->GetAxis(0)->GetLast());
   printf("====\n");
   
   can->cd(iCan++);
index 36880dc..e634cee 100644 (file)
@@ -1,7 +1,13 @@
 
 void testUnfolding() {
+  TBenchmark b;
+
+  b.Start("init");
+
   Load();
 
+  AliLog::SetGlobalDebugLevel(0);
+
   // get the essential
   AliCFDataGrid *measured    = (AliCFDataGrid*) GetMeasuredSpectrum();
   AliCFDataGrid *generated   = (AliCFDataGrid*) GetGeneratedSpectrum();
@@ -11,50 +17,71 @@ void testUnfolding() {
   // create a guessed "a priori" distribution using binning of MC
   THnSparse* guessed = CreateGuessed(((AliCFGridSparse*)generated->GetData())->GetGrid()) ;
   //----
-  AliCFUnfolding unfolding("unfolding","",2,response,efficiency->GetGrid(),((AliCFGridSparse*)measured->GetData())->GetGrid(),guessed);
+
+  TF2* fit2D = new TF2("fit2D","[0]*([2]+[3]*y+[4]*y*y)*x*TMath::Exp(-x/[1])",0.1,0.8,-1.5,1.5);
+  fit2D->SetParameter(0,1);
+  fit2D->SetParameter(1,1);
+  fit2D->SetParameter(2,1);
+  fit2D->SetParameter(3,1);
+  fit2D->SetParameter(4,1);
+  fit2D->SetParLimits(1,0,1);
+
+  AliCFUnfolding unfolding("unfolding","",2,response,efficiency->GetGrid(),((AliCFGridSparse*)measured->GetData())->GetGrid()/*,guessed*/);
   unfolding.SetMaxNumberOfIterations(100);
   unfolding.SetMaxChi2PerDOF(1.e-07);
+  unfolding.UseSmoothing(fit2D,"ren");
   //unfolding.UseSmoothing();
+  
+  b.Stop("init");
+  b.Start("unfolding");
   unfolding.Unfold();
+  b.Stop("unfolding");
+  b.Start("finish");
 
-  THnSparse* result = unfolding.GetUnfolded();
-  //----
-  
-  TCanvas * canvas = new TCanvas("canvas","",1000,700);
-  canvas->Divide(3,3);
+  canvas->cd();
 
-  canvas->cd(1);
   TH2D* h_gen = generated->Project(0,1);
   h_gen->SetTitle("generated");
   h_gen->Draw("lego2");
+  canvas->SaveAs("/tmp/generated.eps");
+  canvas->SaveAs("/tmp/generated.gif");
 
-  canvas->cd(2);
   TH2D* h_meas = measured->Project(0,1);
   h_meas->SetTitle("measured");
   h_meas->Draw("lego2");
-  
-  canvas->cd(3);
-  TH2D* h_guessed = guessed->Projection(1,0);
+  canvas->SaveAs("/tmp/measured.eps");
+  canvas->SaveAs("/tmp/measured.gif");
+
+  TH2D* h_guessed = unfolding.GetOriginalPrior()->Projection(1,0);
   h_guessed->SetTitle("a priori");
   h_guessed->Draw("lego2");
+  canvas->SaveAs("/tmp/apriori.eps");
+  canvas->SaveAs("/tmp/apriori.gif");
 
-  canvas->cd(4);
   TH2D* h_eff = efficiency->Project(0,1);
   h_eff->SetTitle("efficiency");
-  h_eff->Draw("lego2");
+  h_eff->Draw("e");
 
-  canvas->cd(5);
-  TH2D* h_unf = result->Projection(1,0);
+  TH2D* h_unf = unfolding.GetUnfolded()->Projection(1,0);
   h_unf->SetTitle("unfolded");
   h_unf->Draw("lego2");
+  fit2D->Draw("surf same");
+  return;
+  canvas->SaveAs("/tmp/unfolded.eps");
+  canvas->SaveAs("/tmp/unfolded.gif");
+
 
-  canvas->cd(6);
   TH2D* ratio = (TH2D*)h_unf->Clone();
   ratio->SetTitle("unfolded / generated");
   ratio->Divide(h_unf,h_gen,1,1);
-//   ratio->Draw("cont4z");
-//   ratio->Draw("surf2");
+  ratio->GetZaxis()->SetRangeUser(0.5,1.5);
+  //ratio->Draw("cont4z");
   ratio->Draw("lego2");
+  //ratio->Draw("e");
+//   ratio->ProjectionY()->Draw();
+  canvas->SaveAs("/tmp/ratio.eps");
+  canvas->SaveAs("/tmp/ratio.gif");
+   
 
   canvas->cd(7);
   TH2* orig = unfolding.GetOriginalPrior()->Projection(1,0);
@@ -62,19 +89,25 @@ void testUnfolding() {
   orig->Draw("lego2");
 
   canvas->cd(8);
-  AliCFDataGrid* corrected = (AliCFDataGrid*)measured->Clone();
-  corrected->ApplyEffCorrection(*efficiency);
-  TH2D* corr = corrected->Project(0,1);
-  corr->SetTitle("simple correction");
-  corr->Draw("lego2");
+  TH2D* h_est = (TH2D*) unfolding.GetEstMeasured()->Projection(1,0);
+  h_est->SetTitle("est. measured");
+  h_est->Draw("e");
 
   canvas->cd(9);
-  TH2D* ratio2 = (TH2D*) corr->Clone();
-  ratio2->Divide(corr,h_gen,1,1);
-  ratio2->SetTitle("simple correction / generated");
-  ratio2->Draw("cont4z");
+  unfolding.GetUnfolded()->Projection(0)->Draw();
 
-  return;
+  canvas->cd(10);
+  unfolding.GetUnfolded()->Projection(1)->Draw();
+
+  canvas->cd(11);
+  h_gen->ProjectionX()->Draw();
+
+  canvas->cd(12);
+  h_gen->ProjectionY()->Draw();
+
+  b.Stop("finish");
+  Float_t x,y;
+  b.Summary(x,y);
 }
 
 // ====================================================================
@@ -85,6 +118,9 @@ void Load(){
   gSystem->Load("libCORRFW");
   gStyle->SetPalette(1);
   gStyle->SetOptStat(0);
+  TCanvas * canvas = new TCanvas("canvas","",600,400);
+  canvas->SetFillColor(10);
+  canvas->SetFrameFillColor(10);
 }
 
 TObject* GetMeasuredSpectrum() {