Added new functionalities for projections and slices.
authorrvernet <rvernet@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 6 Feb 2009 18:10:08 +0000 (18:10 +0000)
committerrvernet <rvernet@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 6 Feb 2009 18:10:08 +0000 (18:10 +0000)
CORRFW/AliCFContainer.cxx
CORRFW/AliCFContainer.h
CORRFW/AliCFEffGrid.cxx
CORRFW/AliCFEffGrid.h
CORRFW/AliCFGrid.cxx
CORRFW/AliCFGrid.h
CORRFW/AliCFGridSparse.cxx
CORRFW/AliCFGridSparse.h
CORRFW/AliCFVGrid.cxx
CORRFW/AliCFVGrid.h
CORRFW/test/testSlice.C [new file with mode: 0644]

index 8c9bb52..a11a833 100644 (file)
@@ -15,8 +15,8 @@
  **************************************************************************/
 //--------------------------------------------------------------------//
 //                                                                    //
-// AliCFContainer Class                                           //
-// Class to accumulate data on an N-dimensional grids, at different    //
+// AliCFContainer Class                                               //
+// Class to accumulate data on an N-dimensional grids, at different   //
 // selection stages. To be used as an input to get corrections for    //
 // Reconstruction & Trigger efficiency                                // 
 //                                                                    //
@@ -36,7 +36,6 @@ ClassImp(AliCFContainer)
 AliCFContainer::AliCFContainer() : 
   AliCFFrame(),
   fNStep(0),
-  fExclOffEntriesInProj(kTRUE),
   fGrid(0x0)
 {
   //
@@ -47,7 +46,6 @@ AliCFContainer::AliCFContainer() :
 AliCFContainer::AliCFContainer(const Char_t* name, const Char_t* title) : 
   AliCFFrame(name,title),
   fNStep(0),
-  fExclOffEntriesInProj(kTRUE),
   fGrid(0x0)
 {
   // default constructor
@@ -57,7 +55,6 @@ AliCFContainer::AliCFContainer(const Char_t* name, const Char_t* title) :
 AliCFContainer::AliCFContainer(const Char_t* name, const Char_t* title,const Int_t nSelSteps, const Int_t nVarIn, const Int_t * nBinIn, const Double_t *binLimitsIn, const Bool_t useSparse) :  
   AliCFFrame(name,title,nVarIn,nBinIn,binLimitsIn),
   fNStep(0),
-  fExclOffEntriesInProj(kTRUE),
   fGrid(0x0)
 {
   //
@@ -85,7 +82,6 @@ AliCFContainer::AliCFContainer(const Char_t* name, const Char_t* title,const Int
 AliCFContainer::AliCFContainer(const AliCFContainer& c) : 
   AliCFFrame(),
   fNStep(c.fNStep),
-  fExclOffEntriesInProj(c.fExclOffEntriesInProj),
   fGrid(c.fGrid)
 {
   //
@@ -134,7 +130,6 @@ void AliCFContainer::Copy(TObject& c) const
   //
   AliCFContainer& target = (AliCFContainer &) c;
   target.fNStep=fNStep;
-  target.fExclOffEntriesInProj=fExclOffEntriesInProj;
   target.fNVar=fNVar;
   target.fNDim=fNDim;
   target.fNVarBinLimits=fNVarBinLimits;
@@ -173,7 +168,11 @@ TH1D *AliCFContainer::ShowProjection(Int_t ivar, Int_t istep) const
     AliError("Non-existent selection step, return NULL");
     return 0x0;
   }
-  fGrid[istep]->SetExcludeOffEntriesInProj(fExclOffEntriesInProj);
+  if(ivar >= fNVar || ivar < 0){
+    AliError("Non-existent selection step, return NULL");
+    return 0x0;
+  }
+
   return fGrid[istep]->Project(ivar);
 }
 //___________________________________________________________________
@@ -186,7 +185,11 @@ TH2D *AliCFContainer::ShowProjection(Int_t ivar1, Int_t ivar2, Int_t istep) cons
     AliError("Non-existent selection step, return NULL");
     return 0x0;
   }
-  fGrid[istep]->SetExcludeOffEntriesInProj(fExclOffEntriesInProj);
+  if(ivar1 >= fNVar || ivar1 < 0 || ivar2 >= fNVar || ivar2 < 0){
+    AliError("Non-existent selection step, return NULL");
+    return 0x0;
+  }
+
   return fGrid[istep]->Project(ivar1,ivar2);
 }
 //___________________________________________________________________
@@ -200,7 +203,13 @@ TH3D *AliCFContainer::ShowProjection(Int_t ivar1, Int_t ivar2, Int_t ivar3, Int_
     AliError("Non-existent selection step, return NULL");
     return 0x0;
   }
-  fGrid[istep]->SetExcludeOffEntriesInProj(fExclOffEntriesInProj);
+  if(ivar1 >= fNVar || ivar1 < 0 || 
+     ivar2 >= fNVar || ivar2 < 0 ||
+     ivar3 >= fNVar || ivar3 < 0 ) {
+    AliError("Non-existent selection step, return NULL");
+    return 0x0;
+  }
+
   return fGrid[istep]->Project(ivar1,ivar2,ivar3);
 }
 //___________________________________________________________________
@@ -251,6 +260,37 @@ TH3D *AliCFContainer::ShowSlice(Int_t ivar1, Int_t ivar2, Int_t ivar3, Double_t
   }
   return (TH3D*)fGrid[istep]->Slice(ivar1,ivar2,ivar3,varMin,varMax);
 }
+//____________________________________________________________________
+AliCFContainer* AliCFContainer::MakeSlice(Int_t nVars, Int_t* vars, Double_t* varMin, Double_t* varMax) const
+{
+  //
+  // Makes a slice along the "nVars" variables defined in "vars" in range [varMin,varMax]
+  // and returns a new container
+  //
+
+  if (nVars < 1 || nVars > fNVar)   AliError("Bad number of dimensions required for the slice");
+
+  //define new binning for new container
+  Int_t* bins=new Int_t[nVars];
+  for (Int_t iVar=0; iVar<nVars; iVar++) bins[iVar] = fNVarBins[vars[iVar]];
+  AliCFContainer* out = new AliCFContainer(fName,fTitle,fNStep,nVars,bins);
+
+  //set the bin limits
+  for (Int_t iVar=0; iVar<nVars; iVar++) {
+    Double_t *array = new Double_t[fNVarBins[vars[iVar]]+1];
+    GetBinLimits(vars[iVar],array);
+    out->SetBinLimits(iVar,array);
+    delete array;
+  }
+
+  //set grid for each step
+  AliInfo(Form("Making a slice in %d dimension(s)",nVars));
+  for (Int_t iStep=0; iStep<fNStep; iStep++) out->SetGrid(iStep,fGrid[iStep]->Project(nVars,vars,varMin,varMax));
+
+  delete bins;
+  return out;
+}
+
 //____________________________________________________________________
 Long64_t AliCFContainer::Merge(TCollection* list)
 {
@@ -394,5 +434,22 @@ void AliCFContainer::SetRangeUser(Int_t ivar, Double_t varMin, Double_t varMax,
     AliError("Non-existent selection var");
     return ;
   }
-  ((AliCFGridSparse*)fGrid[istep])->GetGrid()->GetAxis(ivar)->SetRangeUser(varMin,varMax);
+  ((AliCFGridSparse*)fGrid[istep])->SetRangeUser(ivar,varMin,varMax);
+}
+
+//_____________________________________________________________________
+void AliCFContainer::SetRangeUser(Double_t* varMin, Double_t* varMax, Int_t istep) 
+{
+  //
+  // set all axis ranges at step istep according to varMin and varMax values
+  //
+  if ( strcmp(fGrid[istep]->ClassName(),"AliCFGrid") ==0 ) {
+    AliWarning("Could not AliCFGrid::SetRangeUser(), function not implemented");
+    return;
+  }
+  if (istep >= fNStep || istep < 0){
+    AliError("Non-existent selection step");
+    return ;
+  }
+  ((AliCFGridSparse*)fGrid[istep])->SetRangeUser(varMin,varMax);
 }
index 9ee3406..deae317 100644 (file)
@@ -29,11 +29,12 @@ class AliCFContainer : public AliCFFrame
   virtual ~AliCFContainer();
   AliCFContainer& operator=(const AliCFContainer& corr);
   virtual Int_t GetNStep() const {return fNStep;};
+
+  virtual void  SetNStep(Int_t nStep) {fNStep=nStep;}
   virtual void  SetBinLimits(Int_t varindex, Double_t * array);
+
   virtual void  Fill(Double_t *var, Int_t istep, Double_t weight=1.);
 
-  virtual void   SetExcludeOffEntriesInProj(Bool_t in){fExclOffEntriesInProj=in;}; 
-  virtual Bool_t GetExcludeOffEntriesInProj( ) const {return fExclOffEntriesInProj;}; 
   virtual Float_t GetOverFlows(Int_t var,Int_t istep) const;
   virtual Float_t GetUnderFlows(Int_t var,Int_t istep)const ;
   virtual Float_t GetEntries(Int_t istep)const ;
@@ -53,15 +54,17 @@ class AliCFContainer : public AliCFFrame
   virtual TH1D* ShowSlice( Int_t ivar, Double_t *varMin, Double_t *varMax, Int_t istep) const;
   virtual TH2D* ShowSlice( Int_t ivar1, Int_t ivar2, Double_t *varMin, Double_t *varMax, Int_t istep) const;
   virtual TH3D* ShowSlice( Int_t ivar1, Int_t ivar2, Int_t ivar3, Double_t *varMin, Double_t *varMax, Int_t istep) const;
+  virtual AliCFContainer*  MakeSlice (Int_t nVars, Int_t* vars, Double_t* varMin, Double_t* varMax) const ;
   virtual void  SetRangeUser(Int_t ivar, Double_t varMin, Double_t varMax, Int_t istep) ;
+  virtual void  SetRangeUser(Double_t* varMin, Double_t* varMax, Int_t istep) ;
+  virtual void  SetGrid(Int_t step, AliCFVGrid* grid) {fGrid[step]=grid;}
   virtual AliCFVGrid * GetGrid(Int_t istep) const {return (AliCFVGrid*)fGrid[istep];};
   
  private:
   Int_t    fNStep; //number of selection steps
-  Bool_t fExclOffEntriesInProj; // exclude under/overflows in 
   AliCFVGrid **fGrid;//[fNStep]
   
-  ClassDef(AliCFContainer,3);
+  ClassDef(AliCFContainer,4);
 };
     
 #endif
index e360155..275ad13 100644 (file)
@@ -242,6 +242,10 @@ TH1D *AliCFEffGrid::Project(Int_t ivar) const
     proj1D =new TH1D(pname,htitle, nbins, bins);
   }  
   
+  //unset the use of axis range to be able to divide the histos
+  fContainer->GetGrid(fSelNum)->UseAxisRange(kFALSE);
+  fContainer->GetGrid(fSelDen)->UseAxisRange(kFALSE);
+
   proj1D->Sumw2();
   proj1D->Divide(fContainer->GetGrid(fSelNum)->Project(ivar),fContainer->GetGrid(fSelDen)->Project(ivar),1.,1.,"B");
   
@@ -277,6 +281,10 @@ TH2D *AliCFEffGrid::Project(Int_t ivar1,Int_t ivar2) const
     proj2D =new TH2D(pname,htitle, nbins1,bins1,nbins2,bins2);
   }  
   
+  //unset the use of axis range to be able to divide the histos
+  fContainer->GetGrid(fSelNum)->UseAxisRange(kFALSE);
+  fContainer->GetGrid(fSelDen)->UseAxisRange(kFALSE);
+  
   proj2D->Sumw2();
   proj2D->Divide(fContainer->GetGrid(fSelNum)->Project(ivar1,ivar2),fContainer->GetGrid(fSelDen)->Project(ivar1,ivar2),1.,1.,"B");
   
@@ -321,6 +329,10 @@ TH3D *AliCFEffGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
     proj3D =new TH3D(pname,htitle, nbins1, bins1,nbins2,bins2,nbins3,bins3);
   }  
   
+  //unset the use of axis range to be able to divide the histos
+  fContainer->GetGrid(fSelNum)->UseAxisRange(kFALSE);
+  fContainer->GetGrid(fSelDen)->UseAxisRange(kFALSE);
+
   proj3D->Sumw2();
   proj3D->Divide(fContainer->GetGrid(fSelNum)->Project(ivar1,ivar2,ivar3),fContainer->GetGrid(fSelDen)->Project(ivar1,ivar2,ivar3),1.,1.,"B");
   
@@ -330,3 +342,4 @@ TH3D *AliCFEffGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
   
   return proj3D;
 } 
+
index 0e3560d..3f6eaae 100644 (file)
@@ -33,6 +33,7 @@ class AliCFEffGrid : public AliCFGridSparse
   virtual TH1D* Project( Int_t ivar) const;
   virtual TH2D* Project( Int_t ivar1, Int_t ivar2) const;
   virtual TH3D* Project( Int_t ivar1, Int_t ivar2,Int_t ivar3) const;
+  virtual AliCFEffGrid* Project(Int_t,Int_t*,Double_t*,Double_t*) const {return 0x0;} //not to be used.
 
   //Efficiency calculation
   virtual void  CalculateEfficiency(Int_t istep1, Int_t istep2);
index 721dfdc..0dfdcda 100644 (file)
@@ -1110,27 +1110,3 @@ 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;
-} 
index bc9f222..a1869ef 100644 (file)
@@ -29,8 +29,6 @@ class AliCFGrid : public AliCFVGrid
 
   virtual void  Fill(Double_t *var, Double_t weight=1.);
 
-  virtual void   SetExcludeOffEntriesInProj(Bool_t in); 
-  virtual Bool_t GetExcludeOffEntriesInProj( ) const; 
   virtual Float_t GetOverFlows(Int_t var) const;
   virtual Float_t GetUnderFlows(Int_t var)const ;
   virtual Float_t GetEntries()const ;
@@ -48,15 +46,19 @@ class AliCFGrid : public AliCFVGrid
   virtual void SetElementError(Int_t *bin, Float_t val); 
   virtual void SetElementError(Double_t *var, Float_t val); 
 
-  virtual TH1D* Project( Int_t ivar) const;
-  virtual TH2D* Project( Int_t ivar1, Int_t ivar2) const;
-  virtual TH3D* Project( Int_t ivar1, Int_t ivar2,Int_t ivar3) const;
+  virtual TH1D*      Project( Int_t ivar) const;
+  virtual TH2D*      Project( Int_t ivar1, Int_t ivar2) const;
+  virtual TH3D*      Project( Int_t ivar1, Int_t ivar2,Int_t ivar3) const;
+  virtual AliCFGrid* Project( Int_t /*nVars*/, Int_t* /*vars*/, Double_t* /*varMin*/, Double_t* /*varMax*/) const
+  {AliWarning("not implemented"); return 0x0;}
   virtual TH1D* Slice( Int_t ivar, Double_t *varMin, Double_t *varMax) const;
   virtual TH2D* Slice( Int_t /*ivar1*/, Int_t /*ivar2*/, Double_t */*varMin*/, Double_t */*varMax*/) const 
   {AliWarning("not implemented"); return 0x0;}
   virtual TH3D* Slice( Int_t /*ivar1*/, Int_t /*ivar2*/, Int_t /*ivar3*/, Double_t */*varMin*/, Double_t */*varMax*/) const 
   {AliWarning("not implemented"); return 0x0;}
 
+  virtual void UseAxisRange(Bool_t b) const {AliWarning("Not implemented because this class is obsolete");}
+
   //basic operations
 
   virtual void SumW2();
index 89a8341..7ef3c19 100755 (executable)
@@ -138,13 +138,6 @@ TH1D *AliCFGridSparse::Project(Int_t ivar) const
   // Make a 1D projection along variable ivar 
   //
 
-  //exclude overflows in hidden dimesniosn by default (used in projections)
-  if(fExclOffEntriesInProj){
-    for(Int_t i=0;i<fNVar;i++){
-      if(i!=ivar)
-       fData->GetAxis(i)->SetBit(TAxis::kAxisRange);
-    }
-  }
   TH1D *hist=fData->Projection(ivar);
   return hist;
 }
@@ -155,13 +148,6 @@ TH2D *AliCFGridSparse::Project(Int_t ivar1, Int_t ivar2) const
   // Make a 2D projection along variables ivar1 & ivar2 
   //
 
-  //exclude overflows by default (used in projections)
-  if(fExclOffEntriesInProj){
-    for(Int_t i=0;i<fNVar;i++){
-      if(i!=ivar1 && i!=ivar2)
-       fData->GetAxis(i)->SetBit(TAxis::kAxisRange);
-    }
-  }
   TH2D *hist=fData->Projection(ivar2,ivar1); //notice inverted axis (THnSparse uses TH3 2d-projection convention...)
   return hist;
 
@@ -172,19 +158,34 @@ TH3D *AliCFGridSparse::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
   //
   // Make a 3D projection along variables ivar1 & ivar2 & ivar3 
   //
-  //exclude overflows by default (used in projections)
-  if(fExclOffEntriesInProj){
-    for(Int_t i=0;i<fNVar;i++){
-      if(i!=ivar1 && i!=ivar2 && i!=ivar3)
-       fData->GetAxis(i)->SetBit(TAxis::kAxisRange);
-    }
-  }
 
   TH3D *hist=fData->Projection(ivar1,ivar2,ivar3); 
   return hist;
 
 }
 
+//___________________________________________________________________
+AliCFGridSparse* AliCFGridSparse::Project(Int_t nVars, Int_t* vars, Double_t* varMin, Double_t* varMax) const
+{
+
+  // binning for new grid
+  Int_t* bins = new Int_t[nVars];
+  for (Int_t iVar=0; iVar<nVars; iVar++) {
+    bins[iVar] = fNVarBins[vars[iVar]];
+  }
+  
+  // create new grid sparse
+  AliCFGridSparse* out = new AliCFGridSparse(fName,fTitle,nVars,bins);
+
+  //set the range in the THnSparse to project
+  THnSparse* clone = ((THnSparse*)fData->Clone());
+  for (Int_t iAxis=0; iAxis<fNVar; iAxis++) {
+    clone->GetAxis(iAxis)->SetRangeUser(varMin[iAxis],varMax[iAxis]);
+  }
+  out->SetGrid(clone->Projection(nVars,vars));
+  return out;
+}
+
 //____________________________________________________________________
 Float_t AliCFGridSparse::GetOverFlows(Int_t ivar) const
 {
@@ -680,13 +681,27 @@ TH3D* AliCFGridSparse::Slice(Int_t iVar1, Int_t iVar2, Int_t iVar3, Double_t *va
   return clone->Projection(iVar1,iVar2,iVar3);
 }
 
+//____________________________________________________________________
+void AliCFGridSparse::SetRangeUser(Int_t iVar, Double_t varMin, Double_t varMax) {
+  //
+  // set range of axis iVar. 
+  //
+  fData->GetAxis(iVar)->SetRangeUser(varMin,varMax);
+  AliWarning(Form("THnSparse axis %d range has been modified",iVar));
+}
+
 //____________________________________________________________________
 void AliCFGridSparse::SetRangeUser(Double_t *varMin, Double_t *varMax) {
   //
   // set range of every axis. varMin and varMax must be of dimension fNVar
   //
   for (Int_t iAxis=0; iAxis<fNVar ; iAxis++) { // set new range for every axis
-    fData->GetAxis(iAxis)->SetRangeUser(varMin[iAxis],varMax[iAxis]);
+    SetRangeUser(iAxis,varMin[iAxis],varMax[iAxis]);
   }
-  AliWarning("THnSparse has been modified");
+  AliWarning("THnSparse axes ranges have been modified");
+}
+
+//____________________________________________________________________
+void AliCFGridSparse::UseAxisRange(Bool_t b) const {
+  for (Int_t iAxis=0; iAxis<fNVar; iAxis++) fData->GetAxis(iAxis)->SetBit(TAxis::kAxisRange,b);
 }
index 23c24a5..e9e2466 100755 (executable)
@@ -48,14 +48,17 @@ class AliCFGridSparse : public AliCFVGrid
   virtual void SetElementError(Int_t *bin, Float_t val) ; 
   virtual void SetElementError(Double_t *var, Float_t val); 
 
-  virtual TH1D* Project( Int_t ivar) const;
-  virtual TH2D* Project( Int_t ivar1, Int_t ivar2) const;
-  virtual TH3D* Project( Int_t ivar1, Int_t ivar2,Int_t ivar3) const;
+  virtual TH1D*            Project( Int_t ivar) const;
+  virtual TH2D*            Project( Int_t ivar1, Int_t ivar2) const;
+  virtual TH3D*            Project( Int_t ivar1, Int_t ivar2,Int_t ivar3) const;
+  virtual AliCFGridSparse* Project(Int_t nVars, Int_t* vars, Double_t* varMin, Double_t* varMax) const ;
   virtual TH1D* Slice(Int_t ivar, Double_t* varMin, Double_t* varMax) const ; 
   virtual TH2D* Slice(Int_t ivar1, Int_t ivar2, Double_t *varMin, Double_t *varMax) const ;
   virtual TH3D* Slice(Int_t ivar1, Int_t ivar2, Int_t ivar3, Double_t *varMin, Double_t *varMax) const ;
+  virtual void  SetRangeUser(Int_t iVar, Double_t varMin, Double_t varMax) ;
   virtual void  SetRangeUser(Double_t* varMin, Double_t* varMax) ;
 
+  virtual void UseAxisRange(Bool_t b) const ;
 
   //basic operations
 
@@ -68,8 +71,8 @@ class AliCFGridSparse : public AliCFVGrid
   virtual void Divide(AliCFVGrid* aGrid1, AliCFVGrid* aGrid2, Double_t c1=1., Double_t c2=1.,Option_t *option=0);
 
   virtual void Rebin(const Int_t* group);
-
-  THnSparse  *GetGrid() const {return fData;};//  Getter for the data Container: a THnSparse
+  virtual void SetGrid(THnSparse* grid) {fData=grid;}
+  THnSparse   *GetGrid() const {return fData;};//  Getter for the data Container: a THnSparse
 
   virtual void Copy(TObject& c) const;
 
index 8c7fb1d..dd984b9 100755 (executable)
@@ -32,7 +32,6 @@ ClassImp(AliCFVGrid)
 //____________________________________________________________________
 AliCFVGrid::AliCFVGrid() : 
   AliCFFrame(),
-  fExclOffEntriesInProj(kTRUE),
   fSumW2(kFALSE)
 {
   // default constructor
@@ -40,7 +39,6 @@ AliCFVGrid::AliCFVGrid() :
 //____________________________________________________________________
 AliCFVGrid::AliCFVGrid(const Char_t* name, const Char_t* title) : 
   AliCFFrame(name,title),
-  fExclOffEntriesInProj(kTRUE),
   fSumW2(kFALSE)
 {
   // default constructor
@@ -49,7 +47,6 @@ AliCFVGrid::AliCFVGrid(const Char_t* name, const Char_t* title) :
 //____________________________________________________________________
 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),
-  fExclOffEntriesInProj(kTRUE),
   fSumW2(kFALSE)
 {
   //
@@ -61,7 +58,6 @@ AliCFVGrid::AliCFVGrid(const Char_t* name, const Char_t* title, const Int_t nVar
 //____________________________________________________________________
 AliCFVGrid::AliCFVGrid(const AliCFVGrid& c) : 
   AliCFFrame(c),
-  fExclOffEntriesInProj(c.fExclOffEntriesInProj),
   fSumW2(c.fSumW2)
 {
   //
index 45a40e4..915c3cc 100755 (executable)
@@ -48,13 +48,16 @@ class AliCFVGrid : public AliCFFrame
   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*       Project( Int_t ivar) const = 0;
+  virtual TH2D*       Project( Int_t ivar1, Int_t ivar2) const = 0;
+  virtual TH3D*       Project( Int_t ivar1, Int_t ivar2,Int_t ivar3) const = 0;
+  virtual AliCFVGrid* Project( Int_t nVars, Int_t* vars, Double_t* varMin, Double_t* varMax) const = 0;
   virtual TH1D* Slice(Int_t ivar, Double_t *varMin, Double_t *varMax) const = 0;
   virtual TH2D* Slice(Int_t ivar1, Int_t ivar2, Double_t *varMin, Double_t *varMax) const = 0;
   virtual TH3D* Slice(Int_t ivar1, Int_t ivar2, Int_t ivar3, Double_t *varMin, Double_t *varMax) const = 0;
 
+  virtual void  UseAxisRange(Bool_t b) const = 0 ;
+
   //basic operations
   virtual void SumW2()=0;
   virtual void Add(AliCFVGrid* aGrid, Double_t c=1.) = 0;
@@ -69,8 +72,6 @@ class AliCFVGrid : public AliCFFrame
 
   //implemented in AliCFVGrid
 
-  virtual void   SetExcludeOffEntriesInProj(Bool_t in){fExclOffEntriesInProj=in;}; 
-  virtual Bool_t GetExcludeOffEntriesInProj( ) const {return fExclOffEntriesInProj;}; 
   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); 
@@ -89,14 +90,13 @@ class AliCFVGrid : public AliCFFrame
 
   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 fExclOffEntriesInProj; // exclude under/overflows in 
   //'hidden dimensions' when performing projections, 
   // default is kTRUE. please notice that 
   // if you you use AliCFGrid instead of AliCFGridSparse, 
   // only option kTRUE is actually available  
   Bool_t   fSumW2;//flag to check if calculation of squared weights enabled
    
-  ClassDef(AliCFVGrid,2);
+  ClassDef(AliCFVGrid,3);
 };
     
 #endif
diff --git a/CORRFW/test/testSlice.C b/CORRFW/test/testSlice.C
new file mode 100644 (file)
index 0000000..d5c7b38
--- /dev/null
@@ -0,0 +1,81 @@
+
+void testSlice() {
+  
+  gStyle->SetPalette(1);
+
+  gSystem->Load("libANALYSIS");
+  gSystem->Load("libCORRFW");
+
+  TFile * f = TFile::Open("output.root");
+
+  AliCFContainer * c_in = (AliCFContainer*)f->Get("container");
+  
+  printf("====\n");
+  printf("old container properties\n");
+  printf("nvar=%d\t nstep=%d\t nbins[0]=%d\t nbins[1]=%d\n",c_in->GetNVar(),c_in->GetNStep(),c_in->GetNBins(0),c_in->GetNBins(1));
+  printf("====\n");
+
+
+  TCanvas * can = new TCanvas("can","",1300,850);
+  can->Divide(3,2);
+  Short_t iCan=1;
+
+  can->cd(iCan++);
+  TH2D* h_in_step0 = c_in->ShowProjection(0,1,0);
+  h_in_step0->SetTitle("input container - step 0");
+  h_in_step0->Draw("text colz");
+
+  can->cd(iCan++);
+  TH2D* h_in_step1 = c_in->ShowProjection(0,1,1) ;
+  h_in_step1->SetTitle("input container - step 1");
+  h_in_step1->Draw("text colz");
+  
+
+  Int_t* vars = new Int_t[1 /*2*/];
+  vars[0]=0;
+  //vars[1]=1;
+
+  Double_t epsilon=1.e-07;
+
+  Double_t varMin[2]={0.0 ,            0.0  };
+  Double_t varMax[2]={2.0 - epsilon ,  1.0  };
+
+
+  can->cd(iCan++);
+  TH1D* h_slice_step0 = c_in->ShowSlice(0,varMin,varMax,0);
+  h_slice_step0->SetTitle("test slice - step 0");
+  h_slice_step0->Draw();
+
+  printf("Creating Slice...\n");
+  AliCFContainer* c_out = c_in->MakeSlice(1,vars,varMin,varMax);
+
+  printf("====\n");
+  printf("new container properties\n");
+  printf("nvar=%d\t nstep=%d\t nbins[0]=%d\n",c_out->GetNVar(),c_out->GetNStep(),c_out->GetNBins(0));
+  printf("range = %d  -> %d\n",((AliCFGridSparse*)c_out->GetGrid(0))->GetGrid()->GetAxis(0)->GetFirst(),((AliCFGridSparse*)c_out->GetGrid(0))->GetGrid()->GetAxis(0)->GetLast());
+  printf("====\n");
+  
+  can->cd(iCan++);
+  TH1D* h_out_step0 = c_out->ShowProjection(0,0);
+  h_out_step0->SetTitle("output container - step 0");
+  h_out_step0->Draw();
+
+  can->cd(iCan++);
+  TH1D* h_out_step1 = c_out->ShowProjection(0,1);
+  h_out_step1->SetTitle("output container - step 1");
+  h_out_step1->Draw();
+
+
+
+  AliCFEffGrid * eff = new AliCFEffGrid("eff","",*c_out);
+  eff->CalculateEfficiency(1,0);
+
+  printf("====\n");
+  printf("efficiency map properties\n");
+  printf("nvar=%d\t nbins[0]=%d\n",eff->GetNVar(),eff->GetNBins(0));
+  printf("====\n");
+  
+  can->cd(iCan++);
+  eff->Project(0)->Draw();
+
+}