update Container Classes to be able to handle also THnSparse-based implementation...
authorarcelli <arcelli@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 17 Jan 2008 18:14:04 +0000 (18:14 +0000)
committerarcelli <arcelli@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 17 Jan 2008 18:14:04 +0000 (18:14 +0000)
19 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
CORRFW/AliCFGrid.h
CORRFW/AliCFSingleTrackTask.C [deleted file]
CORRFW/AliCFSingleTrackTask.cxx [deleted file]
CORRFW/AliCFSingleTrackTask.h [deleted file]
CORRFW/AliCFVGrid.cxx [new file with mode: 0755]
CORRFW/AliCFVGrid.h [new file with mode: 0755]
CORRFW/CORRFWLinkDef.h
CORRFW/libCORRFW.pkg
CORRFW/test/AliCFSingleTrackTask.C
CORRFW/test/AliCFSingleTrackTask.cxx

index dbe12a8..fad6919 100644 (file)
@@ -1,5 +1,18 @@
 /* $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.                  *
+ **************************************************************************/
 //--------------------------------------------------------------------//
 //                                                                    //
 // AliCFContainer Class                                           //
@@ -13,6 +26,7 @@
 //
 #include <AliLog.h>
 #include "AliCFGrid.h"
+//#include "AliCFGridSparse.h"
 #include "AliCFContainer.h"
 
 //____________________________________________________________________
@@ -38,7 +52,7 @@ 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 Float_t *binLimitsIn) :  
+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) :  
   AliCFFrame(name,title,nVarIn,nBinIn,binLimitsIn),
   fNStep(0),
   fGrid(0x0)
@@ -51,11 +65,13 @@ AliCFContainer::AliCFContainer(const Char_t* name, const Char_t* title,const Int
   fNStep=nSelSteps;
 
   // The grids 
-  fGrid = new AliCFGrid*[fNStep]; //the grids at the various selection steps
+  fGrid = new AliCFVGrid*[fNStep]; //the grids at the various selection steps
   char gname[30];
   for(Int_t istep=0;istep<fNStep;istep++){
     sprintf(gname,"%s%s%i",GetName(),"_SelStep", istep);
     fGrid[istep] = new AliCFGrid(gname,title,nVarIn,nBinIn,binLimitsIn); 
+    //fGrid[istep] = new AliCFGridSparse(gname,title,nVarIn,nBinIn,binLimitsIn); 
+    fGrid[istep]->SumW2(); 
   }
 }
 //____________________________________________________________________
@@ -89,7 +105,7 @@ AliCFContainer &AliCFContainer::operator=(const AliCFContainer &c)
   return *this;
 } 
 //____________________________________________________________________
-void AliCFContainer::SetBinLimits(Int_t varindex, Float_t *array)
+void AliCFContainer::SetBinLimits(Int_t varindex, Double_t *array)
 {
   //
   // setting the arrays containing the bin limits 
@@ -126,7 +142,7 @@ void AliCFContainer::Copy(TObject& c) const
     }  
 }
 //____________________________________________________________________
-void AliCFContainer::Fill(Float_t *var, Int_t istep, Float_t weight)
+void AliCFContainer::Fill(Double_t *var, Int_t istep, Double_t weight)
 {
   //
   // Fills the grid at selection step istep for a set of values of the 
@@ -135,7 +151,7 @@ void AliCFContainer::Fill(Float_t *var, Int_t istep, Float_t weight)
   fGrid[istep]->Fill(var,weight);
 }
 //___________________________________________________________________
-TH1F *AliCFContainer::ShowProjection(Int_t ivar, Int_t istep) const
+TH1D *AliCFContainer::ShowProjection(Int_t ivar, Int_t istep) const
 {
   //
   // returns 1-D projection along variable ivar at selection step istep
@@ -143,7 +159,7 @@ TH1F *AliCFContainer::ShowProjection(Int_t ivar, Int_t istep) const
   return fGrid[istep]->Project(ivar);
 }
 //___________________________________________________________________
-TH2F *AliCFContainer::ShowProjection(Int_t ivar1, Int_t ivar2, Int_t istep) const
+TH2D *AliCFContainer::ShowProjection(Int_t ivar1, Int_t ivar2, Int_t istep) const
 {
   //
   // returns 2-D projection along variables ivar1,ivar2 at selection step istep
@@ -151,7 +167,7 @@ TH2F *AliCFContainer::ShowProjection(Int_t ivar1, Int_t ivar2, Int_t istep) cons
   return fGrid[istep]->Project(ivar1,ivar2);
 }
 //___________________________________________________________________
-TH3F *AliCFContainer::ShowProjection(Int_t ivar1, Int_t ivar2, Int_t ivar3, Int_t istep) const
+TH3D *AliCFContainer::ShowProjection(Int_t ivar1, Int_t ivar2, Int_t ivar3, Int_t istep) const
 {
   //
   // returns 3-D projection along variables ivar1,ivar2,ivar3 
@@ -160,12 +176,12 @@ TH3F *AliCFContainer::ShowProjection(Int_t ivar1, Int_t ivar2, Int_t ivar3, Int_
   return fGrid[istep]->Project(ivar1,ivar2,ivar3);
 }
 //___________________________________________________________________
-TH1F *AliCFContainer::ShowSlice(Int_t ivar, Float_t *varMin, Float_t* varMax, Int_t istep) const
+TH1D *AliCFContainer::ShowSlice(Int_t ivar, Double_t *varMin, Double_t* varMax, Int_t istep) const
 {
   //
   // Make a slice along variable ivar at selection level istep in range [varMin,varMax]
   //
-  return (TH1F*)fGrid[istep]->Slice(ivar,varMin,varMax);
+  return (TH1D*)fGrid[istep]->Slice(ivar,varMin,varMax);
 }
 //____________________________________________________________________
 Long64_t AliCFContainer::Merge(TCollection* list)
@@ -196,7 +212,7 @@ Long64_t AliCFContainer::Merge(TCollection* list)
 }
 
 //____________________________________________________________________
-void AliCFContainer::Add(AliCFContainer* aContainerToAdd, Float_t c)
+void AliCFContainer::Add(AliCFContainer* aContainerToAdd, Double_t c)
 {
   //
   //add the content of container aContainerToAdd to the current one
@@ -253,14 +269,14 @@ Int_t AliCFContainer::GetEmptyBins( Int_t istep) const {
   return fGrid[istep]->GetEmptyBins();
 } 
 //____________________________________________________________________
-Int_t AliCFContainer::GetEmptyBins( Int_t istep, Float_t *varMin, Float_t* varMax) const {
+Int_t AliCFContainer::GetEmptyBins( Int_t istep, Double_t *varMin, Double_t* varMax) const {
   //
   // Get overflows in variable var at selection level istep
   //
   return fGrid[istep]->GetEmptyBins(varMin,varMax);
 } 
 //_____________________________________________________________________
-Float_t AliCFContainer::GetIntegral( Int_t istep) const 
+Double_t AliCFContainer::GetIntegral( Int_t istep) const 
 {
   //
   // Get Integral at selection level istep
@@ -268,7 +284,7 @@ Float_t AliCFContainer::GetIntegral( Int_t istep) const
   return fGrid[istep]->GetIntegral();
 }
 //_____________________________________________________________________
-Float_t AliCFContainer::GetIntegral( Int_t istep, Float_t *varMin, Float_t* varMax ) const 
+Double_t AliCFContainer::GetIntegral( Int_t istep, Double_t *varMin, Double_t* varMax ) const 
 {
   //
   // Get Integral at selection level istep
index 14d8d7f..47e91f1 100644 (file)
 
 #include "AliCFFrame.h"
 
-class TH1F;
-class TH2F;
-class TH3F;
-class AliCFGrid;
+class TH1D;
+class TH2D;
+class TH3D;
+class AliCFVGrid;
 
 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 Float_t  *binLimitsIn=0);
+  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);
   AliCFContainer(const AliCFContainer& c);
   
   virtual ~AliCFContainer();
   AliCFContainer& operator=(const AliCFContainer& corr);
   virtual Int_t GetNStep() const {return fNStep;};
-  virtual void  SetBinLimits(Int_t varindex, Float_t * array);
-  virtual void  Fill(Float_t *var, Int_t istep, Float_t weight=1.);
+  virtual void  SetBinLimits(Int_t varindex, Double_t * array);
+  virtual void  Fill(Double_t *var, Int_t istep, Double_t weight=1.);
 
   virtual Float_t GetOverFlows(Int_t var,Int_t istep) const;
   virtual Float_t GetUnderFlows(Int_t var,Int_t istep)const ;
@@ -37,26 +37,26 @@ class AliCFContainer : public AliCFFrame
   virtual Float_t GetUnderFlows(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, Float_t *varMin,Float_t *varMax) const ;
-  virtual Float_t GetIntegral(Int_t istep) const ;
-  virtual Float_t GetIntegral(Int_t istep, Float_t *varMin,Float_t *varMax) 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, Float_t c=1.);
+  virtual void Add(AliCFContainer* aContainerToAdd, Double_t c=1.);
   virtual Long64_t Merge(TCollection* list);
 
-  virtual TH1F* ShowProjection( Int_t ivar, Int_t istep) const;
-  virtual TH2F* ShowProjection( Int_t ivar1, Int_t ivar2, Int_t istep) const;
-  virtual TH3F* ShowProjection( Int_t ivar1, Int_t ivar2,Int_t ivar3, Int_t istep) const;
-  virtual TH1F* ShowSlice( Int_t ivar, Float_t *varMin, Float_t *varMax, Int_t istep) const;
-  virtual AliCFGrid * GetGrid(Int_t istep) const {return fGrid[istep];};
+  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* ShowSlice( Int_t ivar, Double_t *varMin, Double_t *varMax, Int_t istep) const;
+  virtual AliCFVGrid * GetGrid(Int_t istep) const {return fGrid[istep];};
   
  private:
   Int_t    fNStep; //number of selection steps
-  AliCFGrid **fGrid;//[fNStep]
+  AliCFVGrid **fGrid;//[fNStep]
   
-  ClassDef(AliCFContainer,1);
+  ClassDef(AliCFContainer,2);
 };
     
 #endif
index d57398b..95fd2d5 100644 (file)
@@ -1,5 +1,18 @@
 /* $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.                  *
+ **************************************************************************/
 //--------------------------------------------------------------------//
 //                                                                    //
 // AliCFDataGrid Class                                        //
@@ -46,7 +59,7 @@ 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 Float_t *binLimitsIn) :  
+AliCFDataGrid::AliCFDataGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn, const Double_t *binLimitsIn) :  
   AliCFGrid(name,title,nVarIn,nBinIn,binLimitsIn),
   fSelData(-1),
   fContainer(0x0)
@@ -141,16 +154,15 @@ void AliCFDataGrid::ApplyEffCorrection(const AliCFEffGrid &c)
   //Apply the correction
   for(Int_t i=0;i<fNDim;i++){
     eff =c.GetElement(i);    
-    deff =TMath::Sqrt(c.GetElementError(i));    
+    deff =c.GetElementError(i);    
     unc =GetElement(i);    
-    dunc =TMath::Sqrt(GetElementError(i));    
+    dunc =GetElementError(i);    
     if(eff>0 && unc>0){      
       ncorr++;
       corr=unc/eff;
       dcorr=TMath::Sqrt(dunc*dunc/unc/unc+deff*deff/eff/eff)*corr;
       SetElement(i,corr);
-      SetElementError(i,dcorr*dcorr);
-      
+      SetElementError(i,dcorr);
     } else{
       if(unc>0)nnocorr++;
       SetElement(i,0);
@@ -183,13 +195,13 @@ void AliCFDataGrid::ApplyBGCorrection(const AliCFDataGrid &c)
 
   for(Int_t i=0;i<fNDim;i++){
     bkg =c.GetElement(i);    
-    dbkg =TMath::Sqrt(c.GetElementError(i));    
+    dbkg =c.GetElementError(i);    
     unc =GetElement(i);    
-    dunc =TMath::Sqrt(GetElementError(i));    
+    dunc =GetElementError(i);    
     corr=unc-bkg;
-    dcorr=TMath::Sqrt(unc+bkg); //stats only, check this
+    dcorr=TMath::Sqrt(unc+bkg); //stat err only...
     SetElement(i,corr);
-    SetElementError(i,dcorr*dcorr);
+    SetElementError(i,dcorr);
       
   }
 }
index e748a44..20c669a 100644 (file)
@@ -24,7 +24,7 @@ class AliCFDataGrid : public AliCFGrid
  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 Float_t  *binLimitsIn=0);
+  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 AliCFDataGrid& c);
   
@@ -35,7 +35,7 @@ class AliCFDataGrid : public AliCFGrid
   // Methods for handling/correcting data 
 
   virtual void  SetMeasured(Int_t istep);
-  virtual const AliCFGrid*  GetData() {return fContainer->GetGrid(fSelData);};
+  virtual const AliCFVGrid*  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;};
index 26b07d2..44285e6 100644 (file)
@@ -1,5 +1,18 @@
 /* $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.                  *
+ **************************************************************************/
 //--------------------------------------------------------------------//
 //                                                                    //
 // AliCFEffGrid Class                                              //
@@ -17,6 +30,9 @@
 #include <TFile.h>
 #include <AliLog.h>
 #include "AliCFEffGrid.h"
+#include <TH1D.h>
+#include <TH2D.h>
+#include <TH3D.h>
 
 //____________________________________________________________________
 ClassImp(AliCFEffGrid)
@@ -34,7 +50,7 @@ AliCFEffGrid::AliCFEffGrid() :
 }
 
 //____________________________________________________________________
-AliCFEffGrid::AliCFEffGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn, const Float_t *binLimitsIn) :  
+AliCFEffGrid::AliCFEffGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn, const Double_t *binLimitsIn) :  
   AliCFGrid(name,title,nVarIn,nBinIn,binLimitsIn),
   fContainer(0x0),
   fSelNum(-1),
@@ -100,10 +116,11 @@ void AliCFEffGrid::CalculateEfficiency(Int_t istep1,Int_t istep2)
 
   fSelNum=istep1;
   fSelDen=istep2;
-  AliCFGrid *num=fContainer->GetGrid(fSelNum);
-  AliCFGrid *den=fContainer->GetGrid(fSelDen);
+  AliCFVGrid *num=fContainer->GetGrid(fSelNum);
+  AliCFVGrid *den=fContainer->GetGrid(fSelDen);
   num->SumW2();
   den->SumW2();
+  this->SumW2();
   this->Divide(num,den,1.,1.,"B");
 
   Int_t nEmptyBinsNum=0;
@@ -111,7 +128,7 @@ void AliCFEffGrid::CalculateEfficiency(Int_t istep1,Int_t istep2)
   for(Int_t iel=0;iel<fNDim;iel++){
     if(den->GetElement(iel)>0){
       if(num->GetElement(iel)==0)nEmptyBinsNum++; //num==0,den!=0
-      }
+    }
     else{
       nEmptyBinsNumAndDen++;
     }
@@ -121,15 +138,15 @@ void AliCFEffGrid::CalculateEfficiency(Int_t istep1,Int_t istep2)
   AliInfo(Form("The correction map contains %i empty bins ",nEmptyBinsNum+nEmptyBinsNumAndDen));
 } 
 //_____________________________________________________________________
-Float_t AliCFEffGrid::GetAverage() const 
+Double_t AliCFEffGrid::GetAverage() const 
 {
   //
   // Get the average efficiency 
   //
 
-  Float_t val=0;
-  Float_t valnum=0;
-  Float_t valden=0;
+  Double_t val=0;
+  Double_t valnum=0;
+  Double_t valden=0;
   for(Int_t i=0;i<fNDim;i++){
     valnum+=fContainer->GetGrid(fSelNum)->GetElement(i);
     valden+=fContainer->GetGrid(fSelDen)->GetElement(i);
@@ -140,14 +157,14 @@ Float_t AliCFEffGrid::GetAverage() const
   return val;
 } 
 //_____________________________________________________________________
-Float_t AliCFEffGrid::GetAverage(Float_t *varMin, Float_t* varMax ) const 
+Double_t AliCFEffGrid::GetAverage(Double_t *varMin, Double_t* varMax ) const 
 {
   //
   // Get ave efficiency in a range
   //
 
 
-  Float_t val=0;
+  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];
@@ -155,8 +172,8 @@ Float_t AliCFEffGrid::GetAverage(Float_t *varMin, Float_t* varMax ) const
   //Find out the min and max bins
   
   for(Int_t i=0;i<fNVar;i++){
-    Float_t xmin=varMin[i]; // the min values  
-    Float_t xmax=varMax[i]; // the max values  
+    Double_t xmin=varMin[i]; // the min values  
+    Double_t xmax=varMax[i]; // the max values  
     Int_t nbins=fNVarBins[i]+1;
     Float_t *bins=new Float_t[nbins];
     for(Int_t ibin =0;ibin<nbins;ibin++){
@@ -170,8 +187,8 @@ Float_t AliCFEffGrid::GetAverage(Float_t *varMin, Float_t* varMax ) const
     delete [] bins;
   }
   
-  Float_t valnum=0;
-  Float_t valden=0;
+  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;
@@ -205,13 +222,13 @@ void AliCFEffGrid::Copy(TObject& eff) const
     target.fContainer=fContainer;
 }
 //___________________________________________________________________
-TH1F *AliCFEffGrid::Project(Int_t ivar) const
+TH1D *AliCFEffGrid::Project(Int_t ivar) const
 {
   //
   // Make a 1D projection along variable ivar 
   //
  
-  TH1F *proj1D=0;
+  TH1D *proj1D=0;
   Int_t nbins =fNVarBins[ivar];
   Float_t *bins = new Float_t[nbins+1];    
   for(Int_t ibin =0;ibin<nbins+1;ibin++){
@@ -224,22 +241,23 @@ TH1F *AliCFEffGrid::Project(Int_t ivar) const
   sprintf(htitle,"%s%s%i%i%s%i",GetName(),"_SelStep",fSelNum,fSelDen,"_proj1D_var", ivar);
   
   if(!proj1D){
-    proj1D =new TH1F(pname,htitle, nbins, bins);
+    proj1D =new TH1D(pname,htitle, nbins, bins);
   }  
   
+  proj1D->Sumw2();
   proj1D->Divide(fContainer->GetGrid(fSelNum)->Project(ivar),fContainer->GetGrid(fSelDen)->Project(ivar),1.,1.,"B");
   
   delete [] bins; 
   return proj1D;
 } 
 //___________________________________________________________________
-TH2F *AliCFEffGrid::Project(Int_t ivar1,Int_t ivar2) const
+TH2D *AliCFEffGrid::Project(Int_t ivar1,Int_t ivar2) const
 {
   //
   // Make a 2D projection along variable ivar1,ivar2 
   //
  
-  TH2F *proj2D=0;
+  TH2D *proj2D=0;
 
   Int_t nbins1 =fNVarBins[ivar1];
   Float_t *bins1 = new Float_t[nbins1+1];    
@@ -258,9 +276,10 @@ TH2F *AliCFEffGrid::Project(Int_t ivar1,Int_t ivar2) const
   sprintf(htitle,"%s%s%i%i%s%i%i",GetName(),"_SelStep",fSelNum,fSelDen,"_proj2D_var",ivar1,ivar2);
   
   if(!proj2D){
-    proj2D =new TH2F(pname,htitle, nbins1,bins1,nbins2,bins2);
+    proj2D =new TH2D(pname,htitle, nbins1,bins1,nbins2,bins2);
   }  
   
+  proj2D->Sumw2();
   proj2D->Divide(fContainer->GetGrid(fSelNum)->Project(ivar1,ivar2),fContainer->GetGrid(fSelDen)->Project(ivar1,ivar2),1.,1.,"B");
   
   delete [] bins1;
@@ -268,13 +287,13 @@ TH2F *AliCFEffGrid::Project(Int_t ivar1,Int_t ivar2) const
   return proj2D;
 } 
 //___________________________________________________________________
-TH3F *AliCFEffGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
+TH3D *AliCFEffGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
 {
   //
   // Make a 3D projection along variable ivar1,ivar2,ivar3 
   //
 
-  TH3F *proj3D=0;
+  TH3D *proj3D=0;
 
   Int_t nbins1 =fNVarBins[ivar1];
   Int_t nbins2 =fNVarBins[ivar2];
@@ -301,9 +320,10 @@ TH3F *AliCFEffGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
    
   
   if(!proj3D){
-    proj3D =new TH3F(pname,htitle, nbins1, bins1,nbins2,bins2,nbins3,bins3);
+    proj3D =new TH3D(pname,htitle, nbins1, bins1,nbins2,bins2,nbins3,bins3);
   }  
   
+  proj3D->Sumw2();
   proj3D->Divide(fContainer->GetGrid(fSelNum)->Project(ivar1,ivar2,ivar3),fContainer->GetGrid(fSelDen)->Project(ivar1,ivar2,ivar3),1.,1.,"B");
   
   delete [] bins1;
index d1a6786..4df1960 100644 (file)
 
 #include "AliCFGrid.h"
 #include "AliCFContainer.h"
-#include <TNamed.h>
 #include <TTree.h>
-#include <TH1F.h>
-#include <TH2F.h>
-#include <TH3F.h>
+class TH1D;
+class TH2D;
+class TH3D;
 
 class AliCFEffGrid : public AliCFGrid
 {
  public:
   AliCFEffGrid();
-  AliCFEffGrid(const Char_t* name,const Char_t* title, const Int_t nVarIn, const Int_t* nBinIn, const Float_t  *binLimitsIn=0);
+  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 AliCFContainer &c);
   AliCFEffGrid(const AliCFEffGrid& eff);
   
   virtual ~AliCFEffGrid();
   AliCFEffGrid& operator=(const AliCFEffGrid& eff);
-  virtual Float_t GetAverage() const ;
-  virtual Float_t GetAverage(Float_t *varMin,Float_t *varMax) const ;
+  virtual Double_t GetAverage() const ;
+  virtual Double_t GetAverage(Double_t *varMin,Double_t *varMax) const ;
   virtual Int_t GetSelNumStep() const {return fSelNum;};
   virtual Int_t GetSelDenStep() const {return fSelDen;};
-  virtual TH1F* Project( Int_t ivar) const;
-  virtual TH2F* Project( Int_t ivar1, Int_t ivar2) const;
-  virtual TH3F* Project( Int_t ivar1, Int_t ivar2,Int_t ivar3) const;
+  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;
 
   //Efficiency calculation
   virtual void  CalculateEfficiency(Int_t istep1, Int_t istep2);
-  virtual const AliCFGrid*  GetNum() {return fContainer->GetGrid(fSelNum);};
-  virtual const AliCFGrid*  GetDen() {return fContainer->GetGrid(fSelDen);};
+  virtual const AliCFVGrid*  GetNum() {return fContainer->GetGrid(fSelNum);};
+  virtual const AliCFVGrid*  GetDen() {return fContainer->GetGrid(fSelDen);};
   virtual void  SetContainer(const AliCFContainer &c) {fContainer=&c;};
 
   //basic operations
index cdb4a5a..ccf8665 100644 (file)
@@ -1,5 +1,18 @@
 /* $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.                  *
+ **************************************************************************/
 //--------------------------------------------------------------------//
 //                                                                    //
 // AliCFFrame Class                                                 //
@@ -51,7 +64,7 @@ AliCFFrame::AliCFFrame(const Char_t* name, const Char_t* title) :
   // named constructor
 }
 //____________________________________________________________________
-AliCFFrame::AliCFFrame(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn, const Float_t *binLimitsIn) :  
+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),
@@ -106,7 +119,7 @@ AliCFFrame::AliCFFrame(const Char_t* name, const Char_t* title, const Int_t nVar
   //The bin limits
 
   fNVarBinLimits=nbinTot;
-  fVarBinLimits=new Float_t[fNVarBinLimits];
+  fVarBinLimits=new Double_t[fNVarBinLimits];
   if(binLimitsIn){
     for(Int_t i=0;i<fNVarBinLimits;i++){
       fVarBinLimits[i] =binLimitsIn[i];
@@ -154,7 +167,7 @@ AliCFFrame &AliCFFrame::operator=(const AliCFFrame &c)
   return *this;
 } 
 //____________________________________________________________________
-void AliCFFrame::SetBinLimits(Int_t ivar, Float_t *array)
+void AliCFFrame::SetBinLimits(Int_t ivar, Double_t *array)
 {
   //
   // setting the arrays containing the bin limits 
@@ -165,7 +178,7 @@ void AliCFFrame::SetBinLimits(Int_t ivar, Float_t *array)
   } 
 } 
 //____________________________________________________________________
-void AliCFFrame::GetBinLimits(Int_t ivar, Float_t *array) const
+void AliCFFrame::GetBinLimits(Int_t ivar, Double_t *array) const
 {
   //
   // getting the arrays containing the bin limits 
@@ -218,19 +231,19 @@ void AliCFFrame::GetBinIndex(Int_t ind, Int_t *bins ) const
   return;
 }
 //____________________________________________________________________
-Float_t AliCFFrame::GetBinCenter(Int_t ivar, Int_t ibin) const
+Double_t AliCFFrame::GetBinCenter(Int_t ivar, Int_t ibin) const
 {
   //
-  // getting the bin center of a given bin ibin on the dim. (axis) ivar
+  // getting the bin center of a given bin ibin along variable ivar
   //
  
-  Float_t binMin=fVarBinLimits[fOffset[ivar]+ibin];
-  Float_t binMax=fVarBinLimits[fOffset[ivar]+ibin+1];
-  Float_t val=0.5*(binMin+binMax);
+  Double_t binMin=fVarBinLimits[fOffset[ivar]+ibin];
+  Double_t binMax=fVarBinLimits[fOffset[ivar]+ibin+1];
+  Double_t val=0.5*(binMin+binMax);
   return val;
 }
 //____________________________________________________________________
-void AliCFFrame::GetBinCenter(Int_t *ibin, Float_t *binCenter) const
+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 
@@ -239,7 +252,35 @@ void AliCFFrame::GetBinCenter(Int_t *ibin, Float_t *binCenter) const
   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 
+  //
+
+  if(ibin>=fNVarBins[ivar]){
+    AliWarning(Form("bin index out of range, number of bins in variable %i is %i", ivar,fNVarBins[ivar]));
+    return -1;
+  } 
+
+  Double_t binMin=fVarBinLimits[fOffset[ivar]+ibin];
+  Double_t binMax=fVarBinLimits[fOffset[ivar]+ibin+1];
+  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
+  //
+  for(Int_t i=0;i<fNVar;i++){
+    binSizes[i]=GetBinSize(i,ibin[i]);
+  }
 } 
+
 //____________________________________________________________________
 void AliCFFrame::Copy(TObject& c) const
 {
index 615e0b5..396cf18 100644 (file)
 //--------------------------------------------------------------------//
 
 #include <TNamed.h>
-class TCollection;
+
 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 Float_t  *binLimitsIn=0);
+  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, Float_t * array);
-  virtual void  GetBinLimits(Int_t ivar, Float_t * array) const;
+  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;
@@ -34,9 +34,11 @@ class AliCFFrame : public TNamed
   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 void    GetBinCenter(Int_t *ibin, Float_t *binCenter) const;
-  virtual Float_t *GetBinLimits() const {return fVarBinLimits;};
-  virtual Float_t GetBinCenter(Int_t ivar,Int_t ibin) const;
+  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
 
@@ -51,10 +53,10 @@ class AliCFFrame : public TNamed
   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
-  Float_t  *fVarBinLimits;//[fNVarBinLimits] array defining the binLimits
+  Double_t  *fVarBinLimits;//[fNVarBinLimits] array defining the binLimits
 
   
-  ClassDef(AliCFFrame,1);
+  ClassDef(AliCFFrame,2);
 };
     
 #endif
index f137840..d92c750 100644 (file)
@@ -1,33 +1,46 @@
 /* $Id$ */
-
-//--------------------------------------------------------------------//
-//                                                                    //
-// AliCFGrid Class                                                 //
-// Class to accumulate data on an N-dimensional grid, to be used      //
-// as input to get corrections for Reconstruction & Trigger efficiency// 
-//                                                                    //
-// -- Author : S.Arcelli                                              //
-// Still to be done:                                                  //
-// --Implement methods to merge cells                                 //
-// --Interpolate among bins in a range                                // 
-//--------------------------------------------------------------------//
+/**************************************************************************
+ * 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 aventually replaced  byAliCFGridSparse  //
+//---------------------------------------------------------------------//
 //
 //
 #include <AliLog.h>
 #include "AliCFGrid.h"
 #include "TMath.h"
 #include "TROOT.h"
-#include "TH1F.h"
-#include "TH2F.h"
-#include "TH3F.h"
+#include "TH1D.h"
+#include "TH2D.h"
+#include "TH3D.h"
 
 //____________________________________________________________________
 ClassImp(AliCFGrid)
 
 //____________________________________________________________________
 AliCFGrid::AliCFGrid() : 
-  AliCFFrame(),
-  fSumW2(kFALSE),
+  AliCFVGrid(),
   fNunflTot(0),
   fNovflTot(0),
   fNentriesTot(0),
@@ -40,8 +53,7 @@ AliCFGrid::AliCFGrid() :
 }
 //____________________________________________________________________
 AliCFGrid::AliCFGrid(const Char_t* name, const Char_t* title) : 
-  AliCFFrame(name,title),
-  fSumW2(kFALSE),
+  AliCFVGrid(name,title),
   fNunflTot(0),
   fNovflTot(0),
   fNentriesTot(0),
@@ -54,9 +66,8 @@ AliCFGrid::AliCFGrid(const Char_t* name, const Char_t* title) :
 }
 
 //____________________________________________________________________
-AliCFGrid::AliCFGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn, const Float_t *binLimitsIn) :  
-  AliCFFrame(name,title,nVarIn,nBinIn,binLimitsIn),
-  fSumW2(kFALSE),
+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),
   fNunflTot(0),
   fNovflTot(0),
   fNentriesTot(0),
@@ -68,21 +79,13 @@ AliCFGrid::AliCFGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn
   //
   // main constructor
   //
-
-
-  //The underflows
+  //The over/underflows
   fNunfl=new Float_t[fNVar];
   fNovfl= new Float_t[fNVar];
 
 
-  // the grid
-  fData = new Float_t[fNDim]; //num
-
   //Initialization
-  for(Int_t i = 0;i<fNDim;i++)fData[i]=0;
-
   fNunflTot =0;
   fNovflTot =0;
   fNentriesTot =0;
@@ -90,12 +93,19 @@ AliCFGrid::AliCFGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn
     fNunfl[j] =0;
     fNovfl[j] =0;
   }
+
+
+  // the grid
+  fData = new Float_t[fNDim]; //num
+
+  //Initialization
 }
 
 //____________________________________________________________________
 AliCFGrid::AliCFGrid(const AliCFGrid& c) : 
-  AliCFFrame(),
-  fSumW2(kFALSE),
+  AliCFVGrid(c),
   fNunflTot(0),
   fNovflTot(0),
   fNentriesTot(0),
@@ -116,13 +126,12 @@ AliCFGrid::~AliCFGrid()
   //
   // destructor
   //
-  delete fData;
+  if(fNunfl)delete fNunfl;
+  if(fNovfl)delete fNovfl;
+  if(fData)delete fData;
   if(fSumW2)delete fErr2;
-  delete fNunfl;
-  delete fNovfl;
 
 }
-
 //____________________________________________________________________
 AliCFGrid &AliCFGrid::operator=(const AliCFGrid &c)
 {
@@ -151,11 +160,13 @@ Float_t AliCFGrid::GetElement(Int_t *bin) const
  //
   // Get the content in a bin corresponding to a set of bin indexes
   //
-    Int_t ind =GetBinIndex(bin);
-    return GetElement(ind);
+  //-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(Float_t *var) const
+Float_t AliCFGrid::GetElement(Double_t *var) const
 {
   //
   // Get the content in a bin corresponding to a set of input variables
@@ -185,6 +196,10 @@ Float_t AliCFGrid::GetElement(Float_t *var) const
     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);
   }
@@ -197,30 +212,32 @@ Float_t AliCFGrid::GetElement(Float_t *var) const
 Float_t AliCFGrid::GetElementError(Int_t iel) const
 {
   //
-  // Return the squared error on grid element iel
+  // Return the error on grid element iel
   //
   if(iel>=fNDim){
     AliInfo(Form(" element index outside the grid, return -1"));
     return -1.;
   }
-  if(fSumW2)return fErr2[iel];
-  return fData[iel];
+  if(fSumW2)return TMath::Sqrt(fErr2[iel]);
+  return TMath::Sqrt(fData[iel]);
 }
 //____________________________________________________________________
 Float_t AliCFGrid::GetElementError(Int_t *bin) const
 {
   //
-  // Get the squared error in a bin corresponding to a set of bin indeces
+  // Get the error in a bin corresponding to a set of bin indeces
   //
-    Int_t ind =GetBinIndex(bin);
-    return GetElementError(ind);
+  //-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(Float_t *var) const
+Float_t AliCFGrid::GetElementError(Double_t *var) const
 {
   //
-  // Get the squared error in a bin corresponding to a set of input variables
+  // Get the error in a bin corresponding to a set of input variables
   //
   Int_t unfl=0;  
   Int_t ovfl=0;  
@@ -246,6 +263,8 @@ Float_t AliCFGrid::GetElementError(Float_t *var) const
     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);
   }
@@ -272,11 +291,13 @@ void AliCFGrid::SetElement(Int_t *bin, Float_t val)
   //
   // Sets grid element of bin indeces bin to val
   //
-    Int_t ind =GetBinIndex(bin);
-    SetElement(ind,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(Float_t *var, Float_t 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
@@ -305,6 +326,8 @@ void AliCFGrid::SetElement(Float_t *var, Float_t val)
     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);
   }
@@ -316,14 +339,14 @@ void AliCFGrid::SetElement(Float_t *var, Float_t val)
 void AliCFGrid::SetElementError(Int_t iel, Float_t val) 
 {
   //
-  // Set squared error to val on grid element iel
+  // 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;   
+  fErr2[iel]=val*val;   
 }
 //____________________________________________________________________
 void AliCFGrid::SetElementError(Int_t *bin, Float_t val) 
@@ -331,11 +354,13 @@ void AliCFGrid::SetElementError(Int_t *bin, Float_t val)
   //
   // Set squared error to val on grid element of bin indeces bin
   //
-    Int_t ind =GetBinIndex(bin);
-    SetElementError(ind,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);
+  SetElementError(ind,val);
 }
 //____________________________________________________________________
-void AliCFGrid::SetElementError(Float_t *var, Float_t 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
@@ -364,6 +389,9 @@ void AliCFGrid::SetElementError(Float_t *var, Float_t val)
     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);
   }
@@ -372,44 +400,26 @@ void AliCFGrid::SetElementError(Float_t *var, Float_t val)
   }
 } 
 //____________________________________________________________________
-void AliCFGrid::Scale(Int_t iel, Float_t *fact)
+void AliCFGrid::Fill(Double_t *var, Double_t weight)
 {
+
   //
-  //scale content of a certain cell by (positive) fact (with error)
+  // Fill the grid,
+  // given a set of values of the input variable, 
+  // with weight (by default w=1)
   //
-  if(iel>=fNDim){
-    AliInfo(Form(" element index outside the grid, no scaling"));
-    return;
-  }
-  Float_t el,del,elsc,delsc;  
-  if(GetElement(iel)>0 && fact[0]>0){
-    el=GetElement(iel);
-    del=TMath::Sqrt(GetElementError(iel));
-    elsc=el*fact[0];
-    delsc=TMath::Sqrt(del*del/el/el
-                   +fact[1]*fact[1]/fact[0]/fact[0])
-      *elsc;
-    SetElement(iel,elsc);
-    if(fSumW2)SetElementError(iel,delsc*elsc);
+
+
+  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;
   }
-}
-//____________________________________________________________________
-void AliCFGrid::Scale(Int_t *bin, Float_t *fact)
-{
-  //
-  //scale content of a certain cell by (positive) fact (with error)
-  //
-  Int_t iel=GetBinIndex(bin);
-  Scale(iel,fact);
-}
-//____________________________________________________________________
-void AliCFGrid::Scale(Float_t *var, Float_t *fact) 
-{
-  //
-  //scale content of a certain cell by (positive) fact (with error)
-  //
-  Int_t unfl=0;  
-  Int_t ovfl=0;  
+
   for(Int_t i=0;i<fNVar;i++){
     Int_t nbins=fNVarBins[i]+1;
     Float_t *bins=new Float_t[nbins];
@@ -421,79 +431,43 @@ void AliCFGrid::Scale(Float_t *var, Float_t *fact)
     //underflows
 
     if(var[i] < bins[0]){
-      unfl=1;
+      unfl[i]=1;  
+      isunfl=1;
     }
 
     //overflows
 
     if(var[i] > bins[nbins-1]){
-      ovfl=1;
+      ovfl[i]=1;  
+      isovfl=1;
     }
     delete [] bins;
   }
 
-  if(!(ovfl==1 || unfl==1)){
-    Int_t iel=GetBinIndex(fIndex);
-    Scale(iel,fact);
-  }
-  else{
-    AliInfo(Form(" input variables outside the grid, no scaling done"));
-  }
-}
-//____________________________________________________________________
-void AliCFGrid::Scale( Float_t *fact) 
-{
-  //
-  //scale contents of the whole grid by fact
-  //
-  for(Int_t iel=0;iel<fNDim;iel++){
-    Scale(iel,fact);
-  }
-}
-//____________________________________________________________________
-void AliCFGrid::Fill(Float_t *var, Float_t weight)
-{
+  //exclusive under/overflows
 
-  //
-  // Fill the grid,
-  // given a set of values of the input variable, 
-  // with weight (by default w=1)
-  //
-
-  Int_t unfl=0;  
-  Int_t ovfl=0;  
   for(Int_t i=0;i<fNVar;i++){
-    Int_t nbins=fNVarBins[i]+1;
-    Float_t *bins=new Float_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;
-      fNunfl[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;
     }
-
-    //overflows
-
-    if(var[i] > bins[nbins-1]){
-      ovfl=1;
-      fNovfl[i]++;
-    }
-    delete [] bins;
+    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(unfl)fNunflTot++;
-  if(ovfl)fNovflTot++;
+  if(isunfl)fNunflTot++;
+  if(isovfl)fNovflTot++;
 
   //if not ovfl/unfl, fill the element  
-  if(!(ovfl==1 || unfl==1)){
+
+  if(!(isovfl==1 || isunfl==1)){
     Int_t ind =GetBinIndex(fIndex);
     fData[ind]+=weight;
     if(fSumW2)fErr2[ind]+=(weight*weight);
@@ -534,138 +508,8 @@ Float_t AliCFGrid::GetEntries( ) const {
   //
   return fNentriesTot;
 } 
-//____________________________________________________________________
-Int_t AliCFGrid::GetEmptyBins() const {
-  //
-  // Get empty bins 
-  //
-  Int_t val=0;
-  for(Int_t i=0;i<fNDim;i++){
-    if(fData[i]<=0)val++;     
-  }
-  return val;
-} 
-//_____________________________________________________________________
-Int_t AliCFGrid::GetEmptyBins( Float_t *varMin, Float_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++){
-    Float_t xmin=varMin[i]; // the min values  
-    Float_t xmax=varMax[i]; // the min values  
-    Int_t nbins=fNVarBins[i]+1;
-    Float_t *bins=new Float_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;
-  }
-
-  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 && fData[i]<=0)val++;     
-  }
-  AliInfo(Form(" the empty bins = %i ",val)); 
-
-  delete [] indexMin;
-  delete [] indexMax;
-  return val;
-} 
-//____________________________________________________________________
-Int_t AliCFGrid::CheckEfficiencyStats(Float_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;
-}
-//_____________________________________________________________________
-Float_t AliCFGrid::GetIntegral() const 
-{
-  //
-  // Get full Integral
-  //
-  Float_t val=0;
-  for(Int_t i=0;i<fNDim;i++){
-    val+=fData[i];     
-  }
-  return val;  
-} 
-//_____________________________________________________________________
-Float_t AliCFGrid::GetIntegral(Int_t *binMin, Int_t* binMax ) const 
-{
-  //
-  // Get Integral in a range of bin indeces (extremes included)
-  //
-
-  Float_t val=0;
-  for(Int_t i=0;i<fNVar;i++){
-    if((binMin[i]<0) || (binMax[i]>=fNVarBins[i]) || (binMin[i]>binMax[i])){
-      AliInfo(Form(" Bin indeces in variable %i outside allowed range or in reverse order, please check!", i));
-      return val;
-    }
-  }
-  val=GetSum(0,binMin,binMax);
-  return val;
-} 
-//_____________________________________________________________________
-Float_t AliCFGrid::GetIntegral(Float_t *varMin, Float_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++){
-    Float_t xmin=varMin[i]; // the min values  
-    Float_t xmax=varMax[i]; // the min values  
-    Int_t nbins=fNVarBins[i]+1;
-    Float_t *bins=new Float_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;
-  }
-
-  Float_t val=GetIntegral(indexMin,indexMax);
-
-  delete [] indexMin;
-  delete [] indexMax;
-
-  return val;
-} 
 //___________________________________________________________________
-TH1F *AliCFGrid::Project(Int_t ivar) const
+TH1D *AliCFGrid::Project(Int_t ivar) const
 {
   //
   // Make a 1D projection along variable ivar 
@@ -684,17 +528,17 @@ TH1F *AliCFGrid::Project(Int_t ivar) const
   char htitle[40];
   sprintf(htitle,"%s%s_%i",GetName(),"_proj1D_var", ivar);
 
-  TH1F *proj1D=0;
+  TH1D *proj1D=0;
 
   //check if a projection with identical name exist
   TObject *obj = gROOT->FindObject(pname);
-  if (obj && obj->InheritsFrom("TH1F")) {
-    proj1D = (TH1F*)obj;
+  if (obj && obj->InheritsFrom("TH1D")) {
+    proj1D = (TH1D*)obj;
     proj1D->Reset();
   }
 
   if(!proj1D){
-    proj1D =new TH1F(pname,htitle, nbins, bins);
+    proj1D =new TH1D(pname,htitle, nbins, bins);
   }  
 
   delete [] bins;
@@ -720,12 +564,12 @@ TH1F *AliCFGrid::Project(Int_t ivar) const
   delete [] err;
   proj1D->SetBinContent(nbins+1,GetOverFlows(ivar));
   proj1D->SetBinContent(0,GetUnderFlows(ivar));
-  proj1D->SetEntries(GetEntries());
+  proj1D->SetEntries(sum+GetUnderFlows(ivar)+GetOverFlows(ivar));
   return proj1D;
 } 
 
 //___________________________________________________________________
-TH2F *AliCFGrid::Project(Int_t ivar1, Int_t ivar2) const
+TH2D *AliCFGrid::Project(Int_t ivar1, Int_t ivar2) const
 {
   //
   // Make a 2D projection along variable ivar 
@@ -748,17 +592,17 @@ TH2F *AliCFGrid::Project(Int_t ivar1, Int_t ivar2) const
   char htitle[40];
   sprintf(htitle,"%s%s_%i_%i",GetName(),"_proj2D_var",ivar1,ivar2);
 
-  TH2F *proj2D=0;
+  TH2D *proj2D=0;
 
   //check if a projection with identical name exist
   TObject *obj = gROOT->FindObject(pname);
-  if (obj && obj->InheritsFrom("TH2F")) {
-    proj2D = (TH2F*)obj;
+  if (obj && obj->InheritsFrom("TH2D")) {
+    proj2D = (TH2D*)obj;
     proj2D->Reset();
   }
 
   if(!proj2D){
-    proj2D =new TH2F(pname,htitle, nbins1, bins1,nbins2,bins2);
+    proj2D =new TH2D(pname,htitle, nbins1, bins1,nbins2,bins2);
   }  
 
   delete [] bins1;
@@ -802,11 +646,11 @@ TH2F *AliCFGrid::Project(Int_t ivar1, Int_t ivar2) const
   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(GetEntries());
+  proj2D->SetEntries(sum+GetUnderFlows(ivar1)+GetOverFlows(ivar1)+GetUnderFlows(ivar2)+GetOverFlows(ivar2));
   return proj2D;
 } 
 //___________________________________________________________________
-TH3F *AliCFGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
+TH3D *AliCFGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
 {
   //
   // Make a 3D projection along variable ivar 
@@ -834,17 +678,17 @@ TH3F *AliCFGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
   char htitle[40];
   sprintf(htitle,"%s%s_%i_%i_%i",GetName(),"_proj3D_var",ivar1,ivar2,ivar3);
 
-  TH3F *proj3D=0;
+  TH3D *proj3D=0;
 
   //check if a projection with identical name exist
   TObject *obj = gROOT->FindObject(pname);
-  if (obj && obj->InheritsFrom("TH3F")) {
-    proj3D = (TH3F*)obj;
+  if (obj && obj->InheritsFrom("TH3D")) {
+    proj3D = (TH3D*)obj;
     proj3D->Reset();
   }
 
   if(!proj3D){
-    proj3D =new TH3F(pname,htitle, nbins1,bins1,nbins2,bins2,nbins3,bins3);
+    proj3D =new TH3D(pname,htitle, nbins1,bins1,nbins2,bins2,nbins3,bins3);
   }  
 
   delete [] bins1;
@@ -898,12 +742,12 @@ TH3F *AliCFGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
   delete err;
   delete err2;
   delete err3;
-  proj3D->SetEntries(GetEntries());
+  proj3D->SetEntries(sum+GetUnderFlows(ivar1)+GetOverFlows(ivar1)+GetUnderFlows(ivar2)+GetOverFlows(ivar2)+GetUnderFlows(ivar3)+GetOverFlows(ivar3));
   return proj3D;
 } 
 
 //___________________________________________________________________
-TH1F *AliCFGrid::Slice(Int_t ivar, Float_t *varMin, Float_t* varMax) const
+TH1D *AliCFGrid::Slice(Int_t ivar, Double_t *varMin, Double_t* varMax) const
 {
   //
   // Make a slice along variable ivar in range [varMin,varMax]
@@ -922,17 +766,17 @@ TH1F *AliCFGrid::Slice(Int_t ivar, Float_t *varMin, Float_t* varMax) const
   char htitle[40];
   sprintf(htitle,"%s%s_%i",GetName(),"_proj1D_var", ivar);
 
-  TH1F *proj1D=0;
+  TH1D *proj1D=0;
 
   //check if a projection with identical name exist
   TObject *obj = gROOT->FindObject(pname);
-  if (obj && obj->InheritsFrom("TH1F")) {
-    proj1D = (TH1F*)obj;
+  if (obj && obj->InheritsFrom("TH1D")) {
+    proj1D = (TH1D*)obj;
     proj1D->Reset();
   }
 
   if(!proj1D){
-    proj1D =new TH1F(pname,htitle, nbins, bins);
+    proj1D =new TH1D(pname,htitle, nbins, bins);
   }  
 
   delete [] bins;
@@ -954,9 +798,6 @@ TH1F *AliCFGrid::Slice(Int_t ivar, Float_t *varMin, Float_t* varMax) const
     }
     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;
   }
 
@@ -992,36 +833,9 @@ TH1F *AliCFGrid::Slice(Int_t ivar, Float_t *varMin, Float_t* varMax) const
   return proj1D;
 } 
 
-//____________________________________________________________________
-Long64_t AliCFGrid::Merge(TCollection* list)
-{
-  // Merge a list of AliCorrection objects with this (needed for
-  // PROOF). 
-  // Returns the number of merged objects (including this).
-
-  if (!list)
-    return 0;
-  
-  if (list->IsEmpty())
-    return 1;
-
-  TIterator* iter = list->MakeIterator();
-  TObject* obj;
-  
-  Int_t count = 0;
-  while ((obj = iter->Next())) {
-    AliCFGrid* entry = dynamic_cast<AliCFGrid*> (obj);
-    if (entry == 0) 
-      continue;
-    this->Add(entry);
-    count++;
-  }
-
-  return count+1;
-}
 
 //____________________________________________________________________
-void AliCFGrid::Add(AliCFGrid* aGrid, Float_t c)
+void AliCFGrid::Add(AliCFVGrid* aGrid, Double_t c)
 {
   //
   //add aGrid to the current one
@@ -1041,7 +855,7 @@ void AliCFGrid::Add(AliCFGrid* aGrid, Float_t c)
   for(Int_t iel=0;iel<fNDim;iel++){
     fData[iel]+=(c*aGrid->GetElement(iel));
     if(fSumW2){
-      Float_t err=TMath::Sqrt(aGrid->GetElementError(iel));  
+      Float_t err=aGrid->GetElementError(iel);  
       fErr2[iel]+=c*c*err*err;
     }
   }
@@ -1057,7 +871,7 @@ void AliCFGrid::Add(AliCFGrid* aGrid, Float_t c)
   }
 }
 //____________________________________________________________________
-void AliCFGrid::Add(AliCFGrid* aGrid1, AliCFGrid* aGrid2, Float_t c1,Float_t c2)
+void AliCFGrid::Add(AliCFVGrid* aGrid1, AliCFVGrid* aGrid2, Double_t c1,Double_t c2)
 {
   //
   //add aGrid1 and aGrid2
@@ -1081,9 +895,9 @@ void AliCFGrid::Add(AliCFGrid* aGrid1, AliCFGrid* aGrid2, Float_t c1,Float_t c2)
     cont2=aGrid2->GetElement(iel);
     SetElement(iel,c1*cont1+c2*cont2);
     if(fSumW2){
-      err1=TMath::Sqrt(aGrid1->GetElementError(iel));
-      err2=TMath::Sqrt(aGrid2->GetElementError(iel));
-      SetElementError(iel,c1*c1*err1*err1+c2*c2*err2*err2);
+      err1=aGrid1->GetElementError(iel);
+      err2=aGrid2->GetElementError(iel);
+      SetElementError(iel,TMath::Sqrt(c1*c1*err1*err1+c2*c2*err2*err2));
     }
   }
 
@@ -1098,7 +912,7 @@ void AliCFGrid::Add(AliCFGrid* aGrid1, AliCFGrid* aGrid2, Float_t c1,Float_t c2)
   }
 }
 //____________________________________________________________________
-void AliCFGrid::Multiply(AliCFGrid* aGrid, Float_t c)
+void AliCFGrid::Multiply(AliCFVGrid* aGrid, Double_t c)
 {
   //
   //multiply grid aGrid by the current one
@@ -1122,9 +936,9 @@ void AliCFGrid::Multiply(AliCFGrid* aGrid, Float_t c)
     cont2=c*aGrid->GetElement(iel);  
     SetElement(iel,cont1*cont2);
     if(fSumW2){
-      err1=TMath::Sqrt(GetElementError(iel));  
-      err2=TMath::Sqrt(aGrid->GetElementError(iel));  
-      SetElementError(iel,c*c*(cont2*cont2*err1*err1+cont1*cont1*err2*err2));
+      err1=GetElementError(iel);  
+      err2=aGrid->GetElementError(iel);  
+      SetElementError(iel,TMath::Sqrt(c*c*(cont2*cont2*err1*err1+cont1*cont1*err2*err2)));
     }
   }
 
@@ -1139,7 +953,7 @@ void AliCFGrid::Multiply(AliCFGrid* aGrid, Float_t c)
   }
 }
 //____________________________________________________________________
-void AliCFGrid::Multiply(AliCFGrid* aGrid1,AliCFGrid* aGrid2, Float_t c1,Float_t c2)
+void AliCFGrid::Multiply(AliCFVGrid* aGrid1, AliCFVGrid* aGrid2, Double_t c1, Double_t c2)
 {
   //
   //multiply grids aGrid1 and aGrid2
@@ -1162,9 +976,9 @@ void AliCFGrid::Multiply(AliCFGrid* aGrid1,AliCFGrid* aGrid2, Float_t c1,Float_t
     cont2=c2*aGrid2->GetElement(iel);  
     SetElement(iel,cont1*cont2);
     if(fSumW2){
-      err1=TMath::Sqrt(aGrid1->GetElementError(iel));  
-      err2=TMath::Sqrt(aGrid2->GetElementError(iel));  
-      SetElementError(iel,c1*c1*c2*c2*(cont2*cont2*err1*err1+cont1*cont1*err2*err2));
+      err1=aGrid1->GetElementError(iel);  
+      err2=aGrid2->GetElementError(iel);  
+      SetElementError(iel,TMath::Sqrt(c1*c1*c2*c2*(cont2*cont2*err1*err1+cont1*cont1*err2*err2)));
     }
   }
 
@@ -1179,15 +993,12 @@ void AliCFGrid::Multiply(AliCFGrid* aGrid1,AliCFGrid* aGrid2, Float_t c1,Float_t
   }
 }
 //____________________________________________________________________
-void AliCFGrid::Divide(AliCFGrid* aGrid, Float_t c, Option_t *option)
+void AliCFGrid::Divide(AliCFVGrid* aGrid, Double_t c)
 {
   //
   //divide current grid by grid aGrid
   //
 
-  TString opt = option;
-  opt.ToUpper();
-
   if(aGrid->GetNVar()!=fNVar){
     AliInfo("Different number of variables, cannot divide the grids");
     return;
@@ -1200,30 +1011,21 @@ void AliCFGrid::Divide(AliCFGrid* aGrid, Float_t c, Option_t *option)
   
   if(!fSumW2  && aGrid->GetSumW2())SumW2();
 
-  Float_t cont1,cont2,err1,err2,r,den;
+  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=TMath::Sqrt(GetElementError(iel));  
-      err2=TMath::Sqrt(aGrid->GetElementError(iel));  
+      err1=GetElementError(iel);  
+      err2=aGrid->GetElementError(iel);  
       if(!cont2){SetElementError(iel,0.); continue;}
-      if (opt.Contains("B")){
-       if(cont1!=cont2){
-         r=cont1/cont2;            
-         SetElementError(iel,TMath::Abs(((1-2.*r)*err1*err1+r*r*err2*err2)/(cont2*cont2)));
-       }else{
-         SetElementError(iel,0.);
-       }
-      }else{
-        den=cont2*cont2*cont2*c*c;
-       SetElementError(iel,(cont2*cont2*err1*err1+cont1*cont1*err2*err2)/den);
-      }
+      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;
@@ -1235,7 +1037,7 @@ void AliCFGrid::Divide(AliCFGrid* aGrid, Float_t c, Option_t *option)
   }
 }
 //____________________________________________________________________
-void AliCFGrid::Divide(AliCFGrid* aGrid1, AliCFGrid* aGrid2, Float_t c1,Float_t c2, Option_t *option)
+void AliCFGrid::Divide(AliCFVGrid* aGrid1, AliCFVGrid* aGrid2, Double_t c1,Double_t c2, Option_t *option)
 {
   //
   //divide grids aGrid1,aGrid2
@@ -1264,19 +1066,19 @@ void AliCFGrid::Divide(AliCFGrid* aGrid1, AliCFGrid* aGrid2, Float_t c1,Float_t
     if(cont2)SetElement(iel,c1*cont1/(c2*cont2));
     else SetElement(iel,0);
      if(fSumW2){
-      err1=TMath::Sqrt(aGrid1->GetElementError(iel));  
-      err2=TMath::Sqrt(aGrid2->GetElementError(iel));  
+      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::Abs(((1.-2.*r)*err1*err1+r*r*err2*err2)/(cont2*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,c1*c1*(cont2*cont2*err1*err1+cont1*cont1*err2*err2)/den);
+       SetElementError(iel,TMath::Sqrt(c1*c1*(cont2*cont2*err1*err1+cont1*cont1*err2*err2)/den));
       }
     }
   }
@@ -1307,27 +1109,6 @@ void AliCFGrid::SumW2()
 
   fSumW2=kTRUE;
 }
-//_____________________________________________________________________
-Float_t AliCFGrid::GetSum(Int_t ivar, Int_t *binMin, Int_t* binMax) const 
-{
-  //
-  // recursively add over nested loops.... 
-  //
-  static Float_t val;
-  if(ivar==0)val=0.;
-  for(Int_t ibin=binMin[ivar];ibin<=binMax[ivar];ibin++){
-    fIndex[ivar]=ibin;
-    if(ivar<fNVar-1) {
-      val=GetSum(ivar+1,binMin,binMax);
-    }
-    else {
-      Int_t iel=GetBinIndex(fIndex);
-      val+=fData[iel];
-    }
-  }
-
-  return val;
-}
 //____________________________________________________________________
 void AliCFGrid::Copy(TObject& c) const
 {
@@ -1336,27 +1117,13 @@ void AliCFGrid::Copy(TObject& c) const
   //
   AliCFGrid& target = (AliCFGrid &) c;
 
-  target.fNVar=fNVar;
-  target.fNDim=fNDim;
-  target.fSumW2=fSumW2;
-  target.fNVarBinLimits=fNVarBinLimits;
   target.fNunflTot = fNunflTot;
   target.fNovflTot = fNovflTot;
   target.fNentriesTot = fNentriesTot;
-  if (fNVarBins)
-    target.fNVarBins = fNVarBins;
-  if (fVarBinLimits)
-    target.fVarBinLimits = fVarBinLimits;
-  if (fNunfl)
-    target.fNunfl = fNunfl;
   if (fNunfl)
     target.fNunfl = fNunfl;
   if (fNovfl)
     target.fNovfl = fNovfl;
-  if (fProduct)
-    target.fProduct = fProduct;
-  if (fOffset)
-    target.fOffset = fOffset;
   if (fData)
     target.fData = fData;
   if (fErr2)
index 06b4fd2..5722d6c 100644 (file)
@@ -1,92 +1,81 @@
 #ifndef ALICFGRID_H
 #define ALICFGRID_H
 
-/* $Id$ */
-
 //--------------------------------------------------------------------//
 //                                                                    //
 // 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 "AliCFFrame.h"
+#include "AliCFVGrid.h"
 
-class TH1F;
-class TH2F;
-class TH3F;
+class TH1D;
+class TH2D;
+class TH3D;
 
-class AliCFGrid : public AliCFFrame
+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 Float_t  *binLimitsIn=0);
+  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(Float_t *var, Float_t weight=1.);
+
+  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 GetOverFlows()const ;
   virtual Float_t GetUnderFlows()const ;
   virtual Float_t GetEntries()const ;
-  virtual Int_t GetEmptyBins()const ;
-  virtual Int_t CheckEfficiencyStats(Float_t thr) const;
-  virtual Int_t GetSumW2()const {return fSumW2;};
+
   virtual Float_t GetElement(Int_t iel)const; 
   virtual Float_t GetElement(Int_t *bin)const; 
-  virtual Float_t GetElement(Float_t *var)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(Float_t *var)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(Float_t *var, 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(Float_t *var, Float_t val); 
-  virtual void Scale(Int_t iel, Float_t *fact); 
-  virtual void Scale(Int_t* bin, Float_t *fact); 
-  virtual void Scale(Float_t* var, Float_t *fact); 
-  virtual void Scale(Float_t *fact); // To normalize MC to int lumi, for ex. 
-  virtual Int_t GetEmptyBins(Float_t *varMin,Float_t *varMax) const ;
-  virtual Float_t GetIntegral() const ;
-  virtual Float_t GetIntegral(Int_t *binMin,Int_t *binMax) const ;
-  virtual Float_t GetIntegral(Float_t *varMin,Float_t *varMax) const ;
-  virtual TH1F* Project( Int_t ivar) const;
-  virtual TH2F* Project( Int_t ivar1, Int_t ivar2) const;
-  virtual TH3F* Project( Int_t ivar1, Int_t ivar2,Int_t ivar3) const;
-  virtual TH1F* Slice( Int_t ivar, Float_t *varMin, Float_t *varMax) const;
-  virtual Float_t GetSum(Int_t ivar, Int_t *binMin, Int_t* binMax) const; 
+  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 TH1D* Slice( Int_t ivar, Double_t *varMin, Double_t *varMax) const;
 
   //basic operations
 
   virtual void SumW2();
   virtual void Copy(TObject& c) const;
-  virtual void Add(AliCFGrid* aGrid, Float_t c=1.);
-  virtual void Add(AliCFGrid* aGrid1 ,AliCFGrid* aGrid2, Float_t c1=1.,Float_t c2=1.);
-  virtual void Multiply(AliCFGrid* aGrid, Float_t c=1.);
-  virtual void Multiply(AliCFGrid* aGrid1,AliCFGrid* aGrid2, Float_t c1=1.,Float_t c2=1.);
-  virtual void Divide(AliCFGrid* aGrid, Float_t c=1.,Option_t *option=0);
-  virtual void Divide(AliCFGrid* aGrid1, AliCFGrid* aGrid2, Float_t c1=1., Float_t c2=1.,Option_t *option=0);
-  virtual Long64_t Merge(TCollection* list);
+  virtual void Add(AliCFVGrid* aGrid, Double_t c=1.);
+  virtual void Add(AliCFVGrid* aGrid1 ,AliCFVGrid* aGrid2, Double_t c1=1.,Double_t c2=1.);
+  virtual void Multiply(AliCFVGrid* aGrid, Double_t c=1.);
+  virtual void Multiply(AliCFVGrid* aGrid1,AliCFVGrid* aGrid2, Double_t c1=1.,Double_t c2=1.);
+  virtual void Divide(AliCFVGrid* aGrid, Double_t c=1.);
+  virtual void Divide(AliCFVGrid* aGrid1, AliCFVGrid* aGrid2, Double_t c1=1., Double_t c2=1.,Option_t *option=0);
 
   
  protected:
-  Bool_t   fSumW2;//flag to check if calculation of squared weights enabled
+
   Float_t  fNunflTot;//Total number of underflows
   Float_t  fNovflTot;//Total number of underflows
   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,1);
+  ClassDef(AliCFGrid,2);
 };
     
 #endif
diff --git a/CORRFW/AliCFSingleTrackTask.C b/CORRFW/AliCFSingleTrackTask.C
deleted file mode 100644 (file)
index d2263b9..0000000
+++ /dev/null
@@ -1,223 +0,0 @@
-//DEFINITION OF A FEW CONSTANTS
-const Double_t ymin  = -1.0 ;
-const Double_t ymax  =  1.0 ;
-const Double_t ptmin =  0.0 ;
-const Double_t ptmax =  8.0 ;
-const Int_t    mintrackrefsTPC = 2 ;
-const Int_t    mintrackrefsITS = 3 ;
-const Int_t    charge  = 1 ;
-const Int_t    PDG = 211; 
-const Int_t    minclustersTPC = 50 ;
-//----------------------------------------------------
-
-Bool_t AliCFSingleTrackTask(
-                           const Bool_t useGrid = 1,
-                           const char * kTagXMLFile="wn.xml", // XML file containing tags
-                           Long64_t     nentries=TChain::kBigNumber
-                           )
-{
-  
-  TBenchmark benchmark;
-  benchmark.Start("AliSingleTrackTask");
-
-  AliLog::SetGlobalDebugLevel(0);
-
-  Load() ; //load the required libraries
-
-  TChain * analysisChain ;
-
-  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,20000);
-    //  Create an AliTagAnalysis Object and chain the tags
-    AliTagAnalysis   *tagAna = new AliTagAnalysis(); 
-    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
-    analysisChain = new TChain("esdTree");
-    //here put your input data path
-    analysisChain->Add("AliESDs.root");
-  }
-  
-  
-  Info("AliCFSingleTrackTask",Form("CHAIN HAS %d ENTRIES",(Int_t)analysisChain->GetEntries()));
-
-  //CONTAINER DEFINITION
-  Info("AliCFSingleTrackTask","SETUP CONTAINER");
-  //the sensitive variables, their indices
-  Int_t ipt = 0;
-  Int_t iy  = 1;
-  //Setting up the container grid... 
-  Int_t nstep = 4 ; //number of selection steps MC 
-  const Int_t nvar   = 2 ; //number of variables on the grid:pt,y,phi,vtx
-  const Int_t nbin1  = 8 ; //bins in pt
-  const Int_t nbin2  = 8 ; //bins in y 
-  //arrays for the number of bins in each dimension
-  const Int_t iBin[nvar] ={nbin1,nbin2};
-  //arrays for lower bounds :
-  Float_t binLim1[nbin1+1];
-  Float_t binLim2[nbin2+1];
-  //values for bin lower bounds
-  for(Int_t i=0; i<=nbin1; i++) binLim1[i]=(Float_t)ptmin + (ptmax-ptmin)/nbin1*(Float_t)i ; 
-  for(Int_t i=0; i<=nbin2; i++) binLim2[i]=(Float_t)ymin  + (ymax-ymin)  /nbin2*(Float_t)i ;
-  //one "container" for MC
-  AliCFContainer* container = new AliCFContainer("container","container for tracks",nstep,nvar,iBin);
-  //setting the bin limits
-  container -> SetBinLimits(ipt,binLim1);
-  container -> SetBinLimits(iy,binLim2);
-
-
-  //CREATE THE  CUTS -----------------------------------------------
-  
-  // Gen-Level kinematic cuts
-  AliCFTrackKineCuts *mcKineCuts = new AliCFTrackKineCuts("mcKineCuts","MC-level kinematic cuts");
-  mcKineCuts->SetPtRange(ptmin,ptmax);
-  mcKineCuts->SetRapidityRange(ymin,ymax);
-  mcKineCuts->SetChargeMC(charge);
-
-  AliCFParticleGenCuts* mcGenCuts = new AliCFParticleGenCuts("mcGenCuts","MC particle generation cuts");
-  mcGenCuts->SetRequireIsPrimary();
-  mcGenCuts->SetRequirePdgCode(PDG);
-
-  //Acceptance Cuts
-  AliCFAcceptanceCuts *mcAccCuts = new AliCFAcceptanceCuts("mcAccCuts","MC acceptance cuts");
-  mcAccCuts->SetMinNHitITS(mintrackrefsITS);
-  mcAccCuts->SetMinNHitTPC(mintrackrefsTPC);
-
-  // Rec-Level kinematic cuts
-  AliCFTrackKineCuts *recKineCuts = new AliCFTrackKineCuts("recKineCuts","rec-level kine cuts");
-  recKineCuts->SetPtRange(ptmin,ptmax);
-  recKineCuts->SetRapidityRange(ymin,ymax);
-  recKineCuts->SetChargeRec(charge);
-  // QA histograms for rec-level kinematic cuts
-  recKineCuts->SetQAOn(kTRUE);
-
-  AliCFTrackQualityCuts *recQualityCuts = new AliCFTrackQualityCuts("recQualityCuts","rec-level quality cuts");
-  recQualityCuts->SetMinNClusterTPC(minclustersTPC);
-  recQualityCuts->SetRequireITSRefit(kTRUE);
-  // QA histograms for rec-level quality cuts
-  recQualityCuts->SetQAOn(kTRUE);
-
-  AliCFTrackIsPrimaryCuts *recIsPrimaryCuts = new AliCFTrackIsPrimaryCuts("recIsPrimaryCuts","rec-level isPrimary cuts");
-  recIsPrimaryCuts->SetMaxNSigmaToVertex(3);
-  // QA histograms for rec-level primary-check cuts
-  recIsPrimaryCuts->SetQAOn(kTRUE);
-
-  AliCFTrackCutPid* cutPID = new AliCFTrackCutPid("cutPID","ESD_PID") ;
-  Double_t prior[AliPID::kSPECIES] = {0.0244519,
-                                     0.0143988,
-                                     0.805747 ,
-                                     0.0928785,
-                                     0.0625243 };
-  cutPID->SetPriors(prior);
-  cutPID->SetDetectors("TPC TOF");
-  cutPID->SetProbabilityCut(0.0);
-  switch(TMath::Abs(PDG)) {
-  case 11   : cutPID->SetParticleType(AliPID::kElectron, kTRUE); break;
-  case 13   : cutPID->SetParticleType(AliPID::kMuon    , kTRUE); break;
-  case 211  : cutPID->SetParticleType(AliPID::kPion    , kTRUE); break;
-  case 321  : cutPID->SetParticleType(AliPID::kKaon    , kTRUE); break;
-  case 2212 : cutPID->SetParticleType(AliPID::kProton  , kTRUE); break;
-  default   : printf("UNDEFINED PID\n"); break;
-  }
-  cutPID->SetQAOn(kTRUE);
-
-  printf("CREATE MC KINE CUTS\n");
-  TObjArray* mcList = new TObjArray(0) ;
-  mcList->AddLast(mcKineCuts);
-  mcList->AddLast(mcGenCuts);
-
-  printf("CREATE ACCEPTANCE CUTS\n");
-  TObjArray* accList = new TObjArray(0) ;
-  accList->AddLast(mcAccCuts);
-
-  printf("CREATE RECONSTRUCTION CUTS\n");
-  TObjArray* recList = new TObjArray(0) ;
-  recList->AddLast(recKineCuts);
-  recList->AddLast(recQualityCuts);
-
-  printf("CREATE PID CUTS\n");
-  TObjArray* fPIDCutList = new TObjArray(0) ;
-  fPIDCutList->AddLast(cutPID);
-
-
-  //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);
-
-
-  //CREATE THE TASK
-  printf("CREATE TASK\n");
-  // create the task
-  AliCFSingleTrackTask *task = new AliCFSingleTrackTask("AliSingleTrackTask");
-  task->SetCFManager(man); //here is set the CF manager
-
-
-  //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");
-
-  // Create and connect containers for input/output
-
-  //input data
-  AliAnalysisDataContainer *cinput0  = mgr->CreateContainer("cchain0",TChain::Class(),AliAnalysisManager::kInputContainer);
-  // output histo (number of events processed)
-  AliAnalysisDataContainer *coutput0 = mgr->CreateContainer("chist0", TH1I::Class(),AliAnalysisManager::kOutputContainer,"output.root");
-  // output Correction Framework Container (for acceptance & efficiency calculations)
-  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("ccontainer0", AliCFContainer::Class(),AliAnalysisManager::kOutputContainer,"output.root");
-  // output QA histograms 
-  AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("clist0", TList::Class(),AliAnalysisManager::kOutputContainer,"output.root");
-
-  mgr->AddTask(task);
-  mgr->ConnectInput(task,0,cinput0);
-  mgr->ConnectOutput(task,0,coutput0);
-  mgr->ConnectOutput(task,1,coutput1);
-  mgr->ConnectOutput(task,2,coutput2);
-  cinput0->SetData(analysisChain);
-  //NEW INTERFACE TO MC INFORMATION
-  AliMCEventHandler* mcHandler = new AliMCEventHandler();
-  mgr->SetMCtruthEventHandler(mcHandler);
-
-  printf("READY TO RUN\n");
-  //RUN !!!
-  if (mgr->InitAnalysis()) {
-    mgr->PrintStatus();
-    mgr->StartAnalysis("local",analysisChain);
-  }
-
-  benchmark.Stop("AliSingleTrackTask");
-  benchmark.Show("AliSingleTrackTask");
-  
-  return kTRUE ;
-}
-
-void Load() {
-  //remove this file which can cause problems
-  gSystem->Exec("rm $ALICE_ROOT/ANALYSIS/AliAnalysisSelector_cxx.so");
-
-  //load the required aliroot libraries
-  gSystem->Load("libANALYSIS") ;
-  gSystem->Load("libANALYSISRL") ;
-  gSystem->Load("$ALICE_ROOT/CORRFW/libCORRFW.so") ;
-
-  //compile online the task class
-  gSystem->SetIncludePath("-I. -I$ALICE_ROOT/include -I$ROOTSYS/include");
-  gROOT->LoadMacro("./AliCFSingleTrackTask.cxx+");
-}
diff --git a/CORRFW/AliCFSingleTrackTask.cxx b/CORRFW/AliCFSingleTrackTask.cxx
deleted file mode 100644 (file)
index d42c080..0000000
+++ /dev/null
@@ -1,298 +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.                  *
- **************************************************************************/
-
-//-----------------------------------------------------------------------
-// Example of task running on AliEn (CAF?)
-// which provides standard way of calculating acceptance and efficiency
-// between different steps of the procedure.
-// The ouptut of the task is a AliCFContainer from which the efficiencies
-// can be calculated
-//-----------------------------------------------------------------------
-// Author : R. Vernet, Consorzio Cometa - Catania (it)
-//-----------------------------------------------------------------------
-
-
-#ifndef ALICFSINGLETRACKTASK_CXX
-#define ALICFSINGLETRACKTASK_CXX
-#include <TROOT.h>
-#include <TInterpreter.h>
-
-#include "AliCFSingleTrackTask.h"
-#include "TCanvas.h"
-#include "AliStack.h"
-#include "TParticle.h"
-#include "TH1I.h"
-#include "TChain.h"
-#include "AliMCEventHandler.h"
-#include "AliMCEvent.h"
-#include "AliAnalysisManager.h"
-#include "AliESDEvent.h"
-#include "AliCFManager.h"
-#include "AliCFCutBase.h"
-#include "AliCFContainer.h"
-#include "TChain.h"
-#include "AliESDtrack.h"
-#include "AliLog.h"
-ClassImp(AliCFSingleTrackTask)
-//__________________________________________________________________________
-AliCFSingleTrackTask::AliCFSingleTrackTask() :
-  fChain(0x0),
-  fESD(0x0),
-  fCFManager(0x0),
-  fQAHistList(0x0),
-  fHistEventsProcessed(0x0)
-{
-//Defual ctor
-}
-//___________________________________________________________________________
-AliCFSingleTrackTask::AliCFSingleTrackTask(const Char_t* name) :
-  AliAnalysisTask(name,"AliCFSingleTrackTask"),
-  fChain(0x0),
-  fESD(0x0),
-  fCFManager(0x0),
-  fQAHistList(0x0),
-  fHistEventsProcessed(0x0)
-{
-  //
-  // Constructor. Initialization of Inputs and Outputs
-  //
-  Info("AliCFSingleTrackTask","Calling Constructor");
-  DefineInput (0,TChain::Class());
-  DefineOutput(0,TH1I::Class());
-  DefineOutput(1,AliCFContainer::Class());
-  DefineOutput(2,TList::Class());
-}
-
-//___________________________________________________________________________
-AliCFSingleTrackTask& AliCFSingleTrackTask::operator=(const AliCFSingleTrackTask& c) 
-{
-  //
-  // Assignment operator
-  //
-  if (this!=&c) {
-    AliAnalysisTask::operator=(c) ;
-    fChain      = c.fChain;
-    fESD        = c.fESD;
-    fCFManager  = c.fCFManager;
-    fQAHistList = c.fQAHistList ;
-    fHistEventsProcessed = c.fHistEventsProcessed;
-  }
-  return *this;
-}
-
-//___________________________________________________________________________
-AliCFSingleTrackTask::AliCFSingleTrackTask(const AliCFSingleTrackTask& c) :
-  AliAnalysisTask(c),
-  fChain(c.fChain),
-  fESD(c.fESD),
-  fCFManager(c.fCFManager),
-  fQAHistList(c.fQAHistList),
-  fHistEventsProcessed(c.fHistEventsProcessed)
-{
-  //
-  // Copy Constructor
-  //
-}
-
-//___________________________________________________________________________
-AliCFSingleTrackTask::~AliCFSingleTrackTask() {
-  //
-  //destructor
-  //
-  Info("~AliCFSingleTrackTask","Calling Destructor");
-  if (fChain)               delete fChain ;
-  if (fESD)                 delete fESD ;
-  if (fCFManager)           delete fCFManager ;
-  if (fHistEventsProcessed) delete fHistEventsProcessed ;
-  if (fQAHistList) {fQAHistList->Clear(); delete fQAHistList;}
-}
-
-//___________________________________________________________________________
-
-void AliCFSingleTrackTask::Init()
-{
-
-}
-//_________________________________________________
-void AliCFSingleTrackTask::Exec(Option_t *)
-{
-  //
-  // Main loop function
-  //
-  Info("Exec","") ;
-  // Get the mc truth
-  AliMCEventHandler* mcTruth = (AliMCEventHandler*)((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());
-
-  if (!mcTruth) Error("Exec","NO MC INFO FOUND... EXITING\n");
-
-  // transform possible old AliESD into AliESDEvent
-
-  if (fESD->GetAliESDOld()) fESD->CopyFromOldESD(); //transition to new ESD format
-
-  //pass the MC evt handler to the cuts that need it 
-
-  fCFManager->SetEventInfo(mcTruth);
-
-  // Get the MC event 
-  AliMCEvent* mcEvent = mcTruth->MCEvent();
-
-  // MC-event selection
-  Float_t containerInput[2] ;
-        
-  //loop on the MC event
-  for (Int_t ipart=0; ipart<mcEvent->GetNumberOfTracks(); ipart++) { 
-    AliMCParticle *mcPart  = mcEvent->GetTrack(ipart);
-
-    //check the MC-level cuts
-    if (!fCFManager->CheckParticleCuts(AliCFManager::kPartGenCuts,mcPart)) continue;
-
-    containerInput[0] = (Float_t)mcPart->Pt();
-    containerInput[1] = mcPart->Eta() ;
-    //fill the container for Gen-level selection
-    fCFManager->GetParticleContainer()->Fill(containerInput,kStepGenerated);
-    
-    //check the Acceptance-level cuts
-    if (!fCFManager->CheckParticleCuts(AliCFManager::kPartAccCuts,mcPart)) continue;
-    //fill the container for Acceptance-level selection
-    fCFManager->GetParticleContainer()->Fill(containerInput,kStepReconstructible);
-  }    
-
-  //Now go to rec level
-  for (Int_t iTrack = 0; iTrack<fESD->GetNumberOfTracks(); iTrack++) {
-
-    AliESDtrack* track = fESD->GetTrack(iTrack);
-    
-    fCFManager->FillQABeforeParticleCuts(AliCFManager::kPartRecCuts,track);  
-    if (!fCFManager->CheckParticleCuts(AliCFManager::kPartRecCuts,track)) continue;
-    fCFManager->FillQAAfterParticleCuts(AliCFManager::kPartRecCuts,track);
-
-    // is track associated to particle ?
-    if (track->GetLabel()<0) continue;
-    AliMCParticle *mcPart  = mcEvent->GetTrack(track->GetLabel());
-    
-    // check if this track was part of the signal
-    if (!fCFManager->CheckParticleCuts(AliCFManager::kPartGenCuts,mcPart)) continue; 
-    
-    //fill the container
-    Double_t mom[3];
-    track->GetPxPyPz(mom);
-    Double_t pt=TMath::Sqrt(mom[0]*mom[0]+mom[1]*mom[1]);
-    containerInput[0] = pt ;
-    containerInput[1] = track->Eta();
-    fCFManager->GetParticleContainer()->Fill(containerInput,kStepReconstructed) ;   
-    if (!fCFManager->CheckParticleCuts(AliCFManager::kPartSelCuts,track)) continue ;
-    fCFManager->GetParticleContainer()->Fill(containerInput,kStepSelected);
-  }
-  
-  fHistEventsProcessed->Fill(0);
-  PostData(0,fHistEventsProcessed) ;
-  PostData(1,fCFManager->GetParticleContainer()) ;
-  PostData(2,fQAHistList) ;
-}
-
-
-//___________________________________________________________________________
-void AliCFSingleTrackTask::Terminate(Option_t*)
-{
-  // The Terminate() function is the last function to be called during
-  // a query. It always runs on the client, it can be used to present
-  // the results graphically or save the results to file.
-
-  Info("Terminate","");
-  AliAnalysisTask::Terminate();
-
-
-  Double_t max1 = fCFManager->GetParticleContainer()->ShowProjection(0,0)->GetMaximum();
-  Double_t max2 = fCFManager->GetParticleContainer()->ShowProjection(1,0)->GetMaximum();
-
-  fCFManager->GetParticleContainer()->ShowProjection(0,0)->GetYaxis()->SetRangeUser(0,max1*1.2);
-  fCFManager->GetParticleContainer()->ShowProjection(0,1)->GetYaxis()->SetRangeUser(0,max1*1.2);
-  fCFManager->GetParticleContainer()->ShowProjection(0,2)->GetYaxis()->SetRangeUser(0,max1*1.2);
-  fCFManager->GetParticleContainer()->ShowProjection(0,3)->GetYaxis()->SetRangeUser(0,max1*1.2);
-
-  fCFManager->GetParticleContainer()->ShowProjection(1,0)->GetYaxis()->SetRangeUser(0,max2*1.2);
-  fCFManager->GetParticleContainer()->ShowProjection(1,1)->GetYaxis()->SetRangeUser(0,max2*1.2);
-  fCFManager->GetParticleContainer()->ShowProjection(1,2)->GetYaxis()->SetRangeUser(0,max2*1.2);
-  fCFManager->GetParticleContainer()->ShowProjection(1,3)->GetYaxis()->SetRangeUser(0,max2*1.2);
-
-  fCFManager->GetParticleContainer()->ShowProjection(0,0)->SetMarkerStyle(23) ;
-  fCFManager->GetParticleContainer()->ShowProjection(0,1)->SetMarkerStyle(24) ;
-  fCFManager->GetParticleContainer()->ShowProjection(0,2)->SetMarkerStyle(25) ;
-  fCFManager->GetParticleContainer()->ShowProjection(0,3)->SetMarkerStyle(26) ;
-
-  fCFManager->GetParticleContainer()->ShowProjection(1,0)->SetMarkerStyle(23) ;
-  fCFManager->GetParticleContainer()->ShowProjection(1,1)->SetMarkerStyle(24) ;
-  fCFManager->GetParticleContainer()->ShowProjection(1,2)->SetMarkerStyle(25) ;
-  fCFManager->GetParticleContainer()->ShowProjection(1,3)->SetMarkerStyle(26) ;
-
-  TCanvas * c =new TCanvas("c","",1400,800);
-  c->Divide(4,2);
-
-//   TCanvas * c1 =new TCanvas("c1","",600,400);
-  c->cd(1);
-  fCFManager->GetParticleContainer()->ShowProjection(0,0)->Draw("p");
-  c->cd(2);
-  fCFManager->GetParticleContainer()->ShowProjection(0,1)->Draw("p");
-  c->cd(3);
-  fCFManager->GetParticleContainer()->ShowProjection(0,2)->Draw("p");
-  c->cd(4);
-  fCFManager->GetParticleContainer()->ShowProjection(0,3)->Draw("p");
-
-//   TCanvas * c2 =new TCanvas("c2","",600,400);
-  c->cd(5);
-  fCFManager->GetParticleContainer()->ShowProjection(1,0)->Draw("p");
-  c->cd(6);
-  fCFManager->GetParticleContainer()->ShowProjection(1,1)->Draw("p");
-  c->cd(7);
-  fCFManager->GetParticleContainer()->ShowProjection(1,2)->Draw("p");
-  c->cd(8);
-  fCFManager->GetParticleContainer()->ShowProjection(1,3)->Draw("p");
-
-  c->SaveAs("plots.eps");
-
-  delete fHistEventsProcessed ;
-}
-
-//___________________________________________________________________________
-void AliCFSingleTrackTask::ConnectInputData(Option_t *) {
-  //
-  // Initialize branches.
-  //
-  Info("ConnectInputData","ConnectInputData of task %s\n",GetName());
-
-  fChain = (TChain*)GetInputData(0);
-  fChain->SetBranchStatus("*FMD*",0);
-  fChain->SetBranchStatus("*CaloClusters*",0);
-  fESD = new AliESDEvent();
-  fESD->ReadFromTree(fChain);
-}
-
-//___________________________________________________________________________
-void AliCFSingleTrackTask::CreateOutputObjects() {
-  //HERE ONE CAN CREATE OUTPUT OBJECTS, IN PARTICULAR IF THE OBJECT PARAMETERS DON'T NEED
-  //TO BE SET BEFORE THE EXECUTION OF THE TASK
-  //
-  Info("CreateOutputObjects","CreateOutputObjects of task %s\n", GetName());
-
-  //slot #0
-  fHistEventsProcessed = new TH1I("fHistEventsProcessed","",1,0,1) ;
-
-  //slot #2
-  fQAHistList = new TList();
-  fCFManager->InitQAHistos();
-  fCFManager->AddQAHistosToList(fQAHistList);
-}
-
-#endif
diff --git a/CORRFW/AliCFSingleTrackTask.h b/CORRFW/AliCFSingleTrackTask.h
deleted file mode 100644 (file)
index e666161..0000000
+++ /dev/null
@@ -1,76 +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)
-//-----------------------------------------------------------------------
-
-#ifndef ALICFSINGLETRACKTASK_H
-#define ALICFSINGLETRACKTASK_H
-
-#include "AliAnalysisTask.h"
-
-class TH1I;
-class TParticle ;
-class TFile ;
-class AliMCEventHandler;
-class AliESDEvent;
-class AliStack ;
-class AliCFManager;
-class TChain;
-class AliESDtrack;
-
-class AliCFSingleTrackTask : public AliAnalysisTask {
-  public:
-
-  enum {
-    kStepGenerated       = 0,
-    kStepReconstructible = 1,
-    kStepReconstructed   = 2,
-    kStepSelected        = 3
-  };
-
-  AliCFSingleTrackTask();
-  AliCFSingleTrackTask(const Char_t* name);
-  AliCFSingleTrackTask& operator= (const AliCFSingleTrackTask& c);
-  AliCFSingleTrackTask(const AliCFSingleTrackTask& c);
-  virtual ~AliCFSingleTrackTask();
-
-  // ANALYSIS FRAMEWORK STUFF to loop on data and fill output objects
-  void     ConnectInputData(Option_t *option="");
-  void     CreateOutputObjects();
-  void     Exec(Option_t *option);
-  void     Init(); //loads the CF manager
-  void     LocalInit() {Init();} //needed for the slaves 
-  void     Terminate(Option_t *);
-  
-  // CORRECTION FRAMEWORK RELATED FUNCTIONS
-  void           SetCFManager(AliCFManager* io) {fCFManager = io;}   // global correction manager
-  AliCFManager * GetCFManager()                 {return fCFManager;} // get corr manager
- protected:
-
-  TChain         *fChain      ;  //! chained files
-  AliESDEvent    *fESD        ;  //! pointer to the ESD event read
-  AliCFManager   *fCFManager  ;  // pointer to the CF manager
-  TList          *fQAHistList ;  // list of QA histograms
-
-  // Histograms
-  //Number of events
-  TH1I *fHistEventsProcessed; //! simple histo for monitoring the number of events processed
-  
-  ClassDef(AliCFSingleTrackTask,1);
-};
-
-#endif
diff --git a/CORRFW/AliCFVGrid.cxx b/CORRFW/AliCFVGrid.cxx
new file mode 100755 (executable)
index 0000000..dd984b9
--- /dev/null
@@ -0,0 +1,355 @@
+/**************************************************************************
+ * 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
new file mode 100755 (executable)
index 0000000..2d539d8
--- /dev/null
@@ -0,0 +1,95 @@
+#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 GetOverFlows()const = 0;
+  virtual Float_t GetUnderFlows()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 TH1D* Slice( Int_t ivar, Double_t *varMin, Double_t *varMax) const = 0;
+
+  //basic operations
+  virtual void SumW2()=0;
+  virtual void Add(AliCFVGrid* aGrid, Double_t c=1.) = 0;
+  virtual void Add(AliCFVGrid* aGrid1 ,AliCFVGrid* aGrid2, Double_t c1=1.,Double_t c2=1.) = 0;
+  virtual void Multiply(AliCFVGrid* aGrid, Double_t c=1.) = 0;
+  virtual void Multiply(AliCFVGrid* aGrid1,AliCFVGrid* aGrid2, Double_t c1=1.,Double_t c2=1.) = 0;
+  virtual void Divide(AliCFVGrid* aGrid, Double_t c=1.) = 0;
+  virtual void Divide(AliCFVGrid* aGrid1, AliCFVGrid* aGrid2, Double_t c1=1., Double_t c2=1.,Option_t *option=0) = 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;
+  Bool_t   fSumW2;//flag to check if calculation of squared weights enabled
+   
+  ClassDef(AliCFVGrid,1);
+};
+    
+#endif
+
index 67f1cff..267bddf 100644 (file)
@@ -5,6 +5,7 @@
 #pragma link off all functions;
 
 #pragma link C++ class  AliCFFrame+;
+#pragma link C++ class  AliCFVGrid+;
 #pragma link C++ class  AliCFGrid+;
 #pragma link C++ class  AliCFEffGrid+;
 #pragma link C++ class  AliCFDataGrid+;
index 6776485..4b23bf4 100644 (file)
@@ -1,4 +1,5 @@
 SRCS = AliCFFrame.cxx \
+       AliCFVGrid.cxx \
        AliCFGrid.cxx \
        AliCFEffGrid.cxx \
        AliCFDataGrid.cxx \
index 66d7156..764e90b 100644 (file)
@@ -54,22 +54,22 @@ Bool_t AliCFSingleTrackTask(
 
   //CONTAINER DEFINITION
   Info("AliCFSingleTrackTask","SETUP CONTAINER");
-  //the sensitive variables, their indices
+  //the sensitive variables (2 in this example), their indices
   Int_t ipt = 0;
   Int_t iy  = 1;
   //Setting up the container grid... 
   Int_t nstep = 4 ; //number of selection steps MC 
-  const Int_t nvar   = 2 ; //number of variables on the grid:pt,y,phi,vtx
+  const Int_t nvar   = 2 ; //number of variables on the grid:pt,y
   const Int_t nbin1  = 8 ; //bins in pt
   const Int_t nbin2  = 8 ; //bins in y 
   //arrays for the number of bins in each dimension
   const Int_t iBin[nvar] ={nbin1,nbin2};
   //arrays for lower bounds :
-  Float_t binLim1[nbin1+1];
-  Float_t binLim2[nbin2+1];
+  Double_t binLim1[nbin1+1];
+  Double_t binLim2[nbin2+1];
   //values for bin lower bounds
-  for(Int_t i=0; i<=nbin1; i++) binLim1[i]=(Float_t)ptmin + (ptmax-ptmin)/nbin1*(Float_t)i ; 
-  for(Int_t i=0; i<=nbin2; i++) binLim2[i]=(Float_t)ymin  + (ymax-ymin)  /nbin2*(Float_t)i ;
+  for(Int_t i=0; i<=nbin1; i++) binLim1[i]=(Double_t)ptmin + (ptmax-ptmin)/nbin1*(Double_t)i ; 
+  for(Int_t i=0; i<=nbin2; i++) binLim2[i]=(Double_t)ymin  + (ymax-ymin)  /nbin2*(Double_t)i ;
   //one "container" for MC
   AliCFContainer* container = new AliCFContainer("container","container for tracks",nstep,nvar,iBin);
   //setting the bin limits
index d42c080..2ea56e9 100644 (file)
@@ -149,7 +149,7 @@ void AliCFSingleTrackTask::Exec(Option_t *)
   AliMCEvent* mcEvent = mcTruth->MCEvent();
 
   // MC-event selection
-  Float_t containerInput[2] ;
+  Double_t containerInput[2] ;
         
   //loop on the MC event
   for (Int_t ipart=0; ipart<mcEvent->GetNumberOfTracks(); ipart++) {