Some cleaning and simplification in container-related classes and
[u/mrichter/AliRoot.git] / CORRFW / AliCFGrid.cxx
index d92c75014518f4bc29b04f20de1be3be8cce5655..7e5ff07e5eebb922656547e8a94522c8c691ef4f 100644 (file)
 //   Still to be done:                                                 //
 // --Implement methods to merge cells                                  //
 // --Interpolate among bins in a range                                 // 
-// This implementation will be aventually replaced  byAliCFGridSparse  //
+// This implementation will be eventually replaced by AliCFGridSparse  //
 //---------------------------------------------------------------------//
 //
 //
-#include <AliLog.h>
+#include "AliLog.h"
 #include "AliCFGrid.h"
 #include "TMath.h"
 #include "TROOT.h"
@@ -41,8 +41,6 @@ ClassImp(AliCFGrid)
 //____________________________________________________________________
 AliCFGrid::AliCFGrid() : 
   AliCFVGrid(),
-  fNunflTot(0),
-  fNovflTot(0),
   fNentriesTot(0),
   fNunfl(0x0),
   fNovfl(0x0),
@@ -54,8 +52,6 @@ AliCFGrid::AliCFGrid() :
 //____________________________________________________________________
 AliCFGrid::AliCFGrid(const Char_t* name, const Char_t* title) : 
   AliCFVGrid(name,title),
-  fNunflTot(0),
-  fNovflTot(0),
   fNentriesTot(0),
   fNunfl(0x0),
   fNovfl(0x0),
@@ -68,8 +64,6 @@ 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 Double_t *binLimitsIn) :  
   AliCFVGrid(name,title,nVarIn,nBinIn,binLimitsIn),
-  fNunflTot(0),
-  fNovflTot(0),
   fNentriesTot(0),
   fNunfl(0x0),
   fNovfl(0x0),
@@ -86,8 +80,6 @@ AliCFGrid::AliCFGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn
 
 
   //Initialization
-  fNunflTot =0;
-  fNovflTot =0;
   fNentriesTot =0;
   for(Int_t j=0;j<fNVar;j++){
     fNunfl[j] =0;
@@ -97,17 +89,18 @@ AliCFGrid::AliCFGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn
 
   // the grid
  
-  fData = new Float_t[fNDim]; //num
+  fData = new Float_t[fNDim]; 
 
   //Initialization
+  for(Int_t j=0;j<fNDim;j++){
+    fData[j] =0;
+  }
  
 }
 
 //____________________________________________________________________
 AliCFGrid::AliCFGrid(const AliCFGrid& c) : 
   AliCFVGrid(c),
-  fNunflTot(0),
-  fNovflTot(0),
   fNentriesTot(0),
   fNunfl(0x0),
   fNovfl(0x0),
@@ -175,7 +168,7 @@ Float_t AliCFGrid::GetElement(Double_t *var) const
   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];
+    Double_t *bins=new Double_t[nbins];
     for(Int_t ibin =0;ibin<nbins;ibin++){
      bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
     }
@@ -243,7 +236,7 @@ Float_t AliCFGrid::GetElementError(Double_t *var) const
   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];
+    Double_t *bins=new Double_t[nbins];
     for(Int_t ibin =0;ibin<nbins;ibin++){
      bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
     }
@@ -306,7 +299,7 @@ void AliCFGrid::SetElement(Double_t *var, Float_t val)
   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];
+    Double_t *bins=new Double_t[nbins];
     for(Int_t ibin =0;ibin<nbins;ibin++){
      bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
     }
@@ -369,7 +362,7 @@ void AliCFGrid::SetElementError(Double_t *var, Float_t val)
   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];
+    Double_t *bins=new Double_t[nbins];
     for(Int_t ibin =0;ibin<nbins;ibin++){
      bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
     }
@@ -422,7 +415,7 @@ void AliCFGrid::Fill(Double_t *var, Double_t weight)
 
   for(Int_t i=0;i<fNVar;i++){
     Int_t nbins=fNVarBins[i]+1;
-    Float_t *bins=new Float_t[nbins];
+    Double_t *bins=new Double_t[nbins];
     for(Int_t ibin =0;ibin<nbins;ibin++){
      bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
     }
@@ -462,8 +455,6 @@ void AliCFGrid::Fill(Double_t *var, Double_t weight)
   // Total number of entries, overflows and underflows
 
   fNentriesTot++;
-  if(isunfl)fNunflTot++;
-  if(isovfl)fNovflTot++;
 
   //if not ovfl/unfl, fill the element  
 
@@ -481,13 +472,6 @@ Float_t AliCFGrid::GetOverFlows( Int_t ivar) const {
   return fNovfl[ivar];
 } 
 //____________________________________________________________________
-Float_t AliCFGrid::GetOverFlows() const {
-  //
-  // Get overflows 
-  //
-  return fNovflTot;
-} 
-//____________________________________________________________________
 Float_t AliCFGrid::GetUnderFlows( Int_t ivar) const {
   //
   // Get overflows in variable var 
@@ -495,13 +479,6 @@ Float_t AliCFGrid::GetUnderFlows( Int_t ivar) const {
   return fNunfl[ivar];
 } 
 //____________________________________________________________________
-Float_t AliCFGrid::GetUnderFlows() const {
-  //
-  // Get overflows 
-  //
-  return fNunflTot;
-} 
-//____________________________________________________________________
 Float_t AliCFGrid::GetEntries( ) const {
   //
   // Get total entries (in grid + over/underflows) 
@@ -564,7 +541,7 @@ TH1D *AliCFGrid::Project(Int_t ivar) const
   delete [] err;
   proj1D->SetBinContent(nbins+1,GetOverFlows(ivar));
   proj1D->SetBinContent(0,GetUnderFlows(ivar));
-  proj1D->SetEntries(sum+GetUnderFlows(ivar)+GetOverFlows(ivar));
+  proj1D->SetEntries(fNentriesTot);
   return proj1D;
 } 
 
@@ -646,7 +623,7 @@ TH2D *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(sum+GetUnderFlows(ivar1)+GetOverFlows(ivar1)+GetUnderFlows(ivar2)+GetOverFlows(ivar2));
+  proj2D->SetEntries(fNentriesTot);
   return proj2D;
 } 
 //___________________________________________________________________
@@ -742,7 +719,8 @@ TH3D *AliCFGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
   delete err;
   delete err2;
   delete err3;
-  proj3D->SetEntries(sum+GetUnderFlows(ivar1)+GetOverFlows(ivar1)+GetUnderFlows(ivar2)+GetOverFlows(ivar2)+GetUnderFlows(ivar3)+GetOverFlows(ivar3));
+
+  proj3D->SetEntries(fNentriesTot);
   return proj3D;
 } 
 
@@ -789,10 +767,10 @@ TH1D *AliCFGrid::Slice(Int_t ivar, Double_t *varMin, Double_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 min 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];
+    Double_t *bins=new Double_t[nbins];
     for(Int_t ibin =0;ibin<nbins;ibin++){
      bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
     }
@@ -808,6 +786,8 @@ TH1D *AliCFGrid::Slice(Int_t ivar, Double_t *varMin, Double_t* varMax) const
   Int_t *index= new Int_t[fNVar];
   Int_t ielmin=GetBinIndex(indexMin);
   Int_t ielmax=GetBinIndex(indexMax);
+
+
   for(Int_t iel=ielmin;iel<=ielmax;iel++){
     GetBinIndex(iel,index);
     Bool_t isIn=kTRUE;
@@ -819,6 +799,8 @@ TH1D *AliCFGrid::Slice(Int_t ivar, Double_t *varMin, Double_t* varMax) const
   }
 
   delete [] index;
+  delete [] indexMin;
+  delete [] indexMax;
 
 
   for(Int_t ibin =0;ibin<nbins;ibin++){
@@ -863,11 +845,9 @@ void AliCFGrid::Add(AliCFVGrid* aGrid, Double_t c)
   //Add entries, overflows and underflows
 
   fNentriesTot+= c*aGrid->GetEntries();
-  fNunflTot+= c*aGrid->GetUnderFlows();
-  fNovflTot+= c*aGrid->GetOverFlows();
   for(Int_t j=0;j<fNVar;j++){
     fNunfl[j]+= c*aGrid->GetUnderFlows(j);
-    fNovfl[j]+= c*aGrid->GetUnderFlows(j);
+    fNovfl[j]+= c*aGrid->GetOverFlows(j);
   }
 }
 //____________________________________________________________________
@@ -904,11 +884,9 @@ void AliCFGrid::Add(AliCFVGrid* aGrid1, AliCFVGrid* aGrid2, Double_t c1,Double_t
   //Add entries, overflows and underflows
 
   fNentriesTot= c1*aGrid1->GetEntries()+c2*aGrid2->GetEntries();
-  fNunflTot= c1*aGrid1->GetUnderFlows()+c2*aGrid2->GetUnderFlows();
-  fNovflTot= c1*aGrid1->GetOverFlows()+c2*aGrid2->GetOverFlows();
   for(Int_t j=0;j<fNVar;j++){
     fNunfl[j]= c1*aGrid1->GetUnderFlows(j)+c2*aGrid2->GetUnderFlows(j);
-    fNovfl[j]= c1*aGrid1->GetUnderFlows(j)+c2*aGrid2->GetUnderFlows(j);
+    fNovfl[j]= c1*aGrid1->GetOverFlows(j)+c2*aGrid2->GetOverFlows(j);
   }
 }
 //____________________________________________________________________
@@ -945,11 +923,9 @@ void AliCFGrid::Multiply(AliCFVGrid* aGrid, Double_t c)
   //Set entries to the number of bins, preserve original overflows and underflows
 
   fNentriesTot=fNDim;
-  fNunflTot=GetUnderFlows();
-  fNovflTot=GetOverFlows();
   for(Int_t j=0;j<fNVar;j++){
     fNunfl[j]= GetUnderFlows(j);
-    fNovfl[j]= GetUnderFlows(j);
+    fNovfl[j]= GetOverFlows(j);
   }
 }
 //____________________________________________________________________
@@ -985,11 +961,9 @@ void AliCFGrid::Multiply(AliCFVGrid* aGrid1, AliCFVGrid* aGrid2, Double_t c1, Do
   //Set entries to the number of bins, preserve original overflows and underflows
 
   fNentriesTot=fNDim;
-  fNunflTot=GetUnderFlows();
-  fNovflTot=GetOverFlows();
   for(Int_t j=0;j<fNVar;j++){
     fNunfl[j]= GetUnderFlows(j);
-    fNovfl[j]= GetUnderFlows(j);
+    fNovfl[j]= GetOverFlows(j);
   }
 }
 //____________________________________________________________________
@@ -1029,11 +1003,9 @@ void AliCFGrid::Divide(AliCFVGrid* aGrid, Double_t c)
   //Set entries to the number of bins, preserve original overflows and underflows
 
   fNentriesTot=fNDim;
-  fNunflTot=GetUnderFlows();
-  fNovflTot=GetOverFlows();
   for(Int_t j=0;j<fNVar;j++){
     fNunfl[j]= GetUnderFlows(j);
-    fNovfl[j]= GetUnderFlows(j);
+    fNovfl[j]= GetOverFlows(j);
   }
 }
 //____________________________________________________________________
@@ -1086,12 +1058,22 @@ void AliCFGrid::Divide(AliCFVGrid* aGrid1, AliCFVGrid* aGrid2, Double_t c1,Doubl
   //Set entries to the number of bins, preserve original overflows and underflows
 
   fNentriesTot=fNDim;
-  fNunflTot=GetUnderFlows();
-  fNovflTot=GetOverFlows();
   for(Int_t j=0;j<fNVar;j++){
     fNunfl[j]= GetUnderFlows(j);
-    fNovfl[j]= GetUnderFlows(j);
+    fNovfl[j]= GetOverFlows(j);
+  }
+}
+//____________________________________________________________________
+void AliCFGrid::Rebin(const Int_t* group)
+{
+  //
+  // Not yet implemented
+  //
+  for(Int_t i=0;i<fNVar;i++){
+    if(group[i]!=1)AliInfo(Form(" merging bins along dimension %i in groups of %i bins", i,group[i]));
   }
+  AliInfo(Form("This method was so far not implemented for AliCFGrid, but it is available for AliCFGridSparse"));
+
 }
 //____________________________________________________________________
 void AliCFGrid::SumW2()
@@ -1117,8 +1099,6 @@ void AliCFGrid::Copy(TObject& c) const
   //
   AliCFGrid& target = (AliCFGrid &) c;
 
-  target.fNunflTot = fNunflTot;
-  target.fNovflTot = fNovflTot;
   target.fNentriesTot = fNentriesTot;
   if (fNunfl)
     target.fNunfl = fNunfl;
@@ -1130,3 +1110,27 @@ void AliCFGrid::Copy(TObject& c) const
     target.fErr2 = fErr2;
   
 }
+//____________________________________________________________________
+void AliCFGrid::SetExcludeOffEntriesInProj(Bool_t in)
+{
+  //
+  // require under/overflows in 'hidden dimensions' to be excluded
+  // or included, when performing projections.
+  // For AliCFGrid implementation, only option = kTRUE is available
+
+  if(!in){
+    AliInfo(Form("This option is not available for AliCFGrid, Under/Overflows in hidden dimensions are always excluded")); 
+    return;
+  }
+
+  fExclOffEntriesInProj=in;
+} 
+//____________________________________________________________________
+Bool_t AliCFGrid::GetExcludeOffEntriesInProj( ) const 
+{
+  //
+  // return flag saying whether under/overflows are excluded in projections 
+  //
+  
+  return fExclOffEntriesInProj;
+}