X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=CORRFW%2FAliCFContainer.cxx;h=06cfeedc1edc46d3e935c8c49d67fa77fbbfb287;hb=9e5366953cf58970b8bdd5f011a764e8b4d8e78b;hp=11a20611c2be4220557d1af792f35d49df75895c;hpb=a8b83c8771f3fb9537c836b7c2fd81b0d0efef25;p=u%2Fmrichter%2FAliRoot.git

diff --git a/CORRFW/AliCFContainer.cxx b/CORRFW/AliCFContainer.cxx
index 11a20611c2b..06cfeedc1ed 100644
--- a/CORRFW/AliCFContainer.cxx
+++ b/CORRFW/AliCFContainer.cxx
@@ -25,7 +25,6 @@
 //
 //
 #include <AliLog.h>
-#include "AliCFGrid.h"
 #include "AliCFGridSparse.h"
 #include "AliCFContainer.h"
 #include "TAxis.h"
@@ -42,52 +41,36 @@ AliCFContainer::AliCFContainer() :
   // default constructor
   //
 }
-//____________________________________________________________________
-AliCFContainer::AliCFContainer(const Char_t* name, const Char_t* title) : 
-  AliCFFrame(name,title),
-  fNStep(0),
-  fGrid(0x0)
-{
-  // default constructor
-}
 
 //____________________________________________________________________
-AliCFContainer::AliCFContainer(const Char_t* name, const Char_t* title,const Int_t nSelSteps, const Int_t nVarIn, const Int_t * nBinIn, const Double_t *binLimitsIn, const Bool_t useSparse) :  
-  AliCFFrame(name,title,nVarIn,nBinIn,binLimitsIn),
-  fNStep(0),
+AliCFContainer::AliCFContainer(const Char_t* name, const Char_t* title, const Int_t nSelSteps, const Int_t nVarIn, const Int_t* nBinIn) :  
+  AliCFFrame(name,title),
+  fNStep(nSelSteps),
   fGrid(0x0)
 {
   //
   // main constructor
   //
 
-  // The selection steps
-  fNStep=nSelSteps;
-
   // The grids 
-  fGrid = new AliCFVGrid*[fNStep]; //the grids at the various selection steps
-  char gname[30];
-  for(Int_t istep=0;istep<fNStep;istep++){
-    sprintf(gname,"%s%s%i",GetName(),"_SelStep", istep);
-    if(!useSparse){
-      fGrid[istep] = new AliCFGrid(gname,title,nVarIn,nBinIn,binLimitsIn); 
-      }
-    else{
-      fGrid[istep] = new AliCFGridSparse(gname,title,nVarIn,nBinIn,binLimitsIn); 
-    }
-    fGrid[istep]->SumW2(); 
+  fGrid = new AliCFGridSparse*[fNStep]; //the grids at the various selection steps
+  for (Int_t istep=0; istep<fNStep; istep++) {
+    fGrid[istep] = new AliCFGridSparse(Form("%s_SelStep%d",name,istep),Form("step%d",istep),nVarIn,nBinIn);
+    fGrid[istep]->SumW2();
   }
+  for (Int_t iVar=0; iVar<nVarIn; iVar++) SetVarTitle(iVar,Form("var%d",iVar));
+  AliInfo(Form("Grids created for %d steps required  \n =>  Don't forget to set the bin limits !!",fNStep));
 }
 //____________________________________________________________________
-AliCFContainer::AliCFContainer(const AliCFContainer& c) : 
-  AliCFFrame(),
-  fNStep(c.fNStep),
-  fGrid(c.fGrid)
+AliCFContainer::AliCFContainer(const AliCFContainer& c) :
+  AliCFFrame(c.fName,c.fTitle),
+  fNStep(0),
+  fGrid(0x0)
 {
   //
   // copy constructor
   //
-  ((AliCFContainer &)c).Copy(*this);
+  c.Copy(*this);
 }
 //____________________________________________________________________
 AliCFContainer::~AliCFContainer()
@@ -95,8 +78,11 @@ AliCFContainer::~AliCFContainer()
   //
   // destructor
   //
-  if(fGrid)delete [] fGrid;
-
+  if (fGrid) {
+    for ( Int_t istep=0; istep<fNStep; istep++ ) 
+      delete fGrid[istep];
+  }
+  delete [] fGrid;
 }
 //____________________________________________________________________
 AliCFContainer &AliCFContainer::operator=(const AliCFContainer &c)
@@ -104,49 +90,27 @@ AliCFContainer &AliCFContainer::operator=(const AliCFContainer &c)
   //
   // assigment operator
   //
-  if (this != &c)
-    ((AliCFContainer &) c).Copy(*this);
+  if (this != &c) c.Copy(*this);
   return *this;
 } 
-//____________________________________________________________________
-void AliCFContainer::SetBinLimits(Int_t varindex, Double_t *array)
-{
-  //
-  // setting the arrays containing the bin limits 
-  //
-  Int_t nbins=fNVarBins[varindex]+1;
-  for(Int_t i=0;i<nbins;i++){
-    fVarBinLimits[fOffset[varindex]+i] =array[i];
-  } 
-  for(Int_t istep=0;istep<fNStep;istep++){
-    fGrid[istep]->SetBinLimits(varindex,array);
-  }
-} 
+
 //____________________________________________________________________
 void AliCFContainer::Copy(TObject& c) const
 {
   //
   // copy function
   //
+  AliCFFrame::Copy(c);
   AliCFContainer& target = (AliCFContainer &) c;
-  target.fNStep=fNStep;
-  target.fNVar=fNVar;
-  target.fNDim=fNDim;
-  target.fNVarBinLimits=fNVarBinLimits;
-  if (fNVarBins)
-    target.fNVarBins = fNVarBins;
-  if (fVarBinLimits)
-    target.fVarBinLimits = fVarBinLimits;
-  if (fGrid)
-    target.fGrid = fGrid;
-    for(Int_t istep=0;istep<fNStep;istep++){
-      for(Int_t iel=0;iel<fNDim;iel++){
-	target.fGrid[istep]->SetElement(iel,fGrid[istep]->GetElement(iel));
-      } 
-    }  
+  target.fNStep = fNStep;
+  target.fGrid  = new AliCFGridSparse*[fNStep];
+  for (Int_t iStep=0; iStep<fNStep; iStep++) {
+    if (fGrid[iStep])  target.fGrid[iStep] = new AliCFGridSparse(*(fGrid[iStep]));
+  }
 }
+
 //____________________________________________________________________
-void AliCFContainer::Fill(Double_t *var, Int_t istep, Double_t weight)
+void AliCFContainer::Fill(const Double_t *var, Int_t istep, Double_t weight)
 {
   //
   // Fills the grid at selection step istep for a set of values of the 
@@ -158,137 +122,84 @@ void AliCFContainer::Fill(Double_t *var, Int_t istep, Double_t weight)
   }
   fGrid[istep]->Fill(var,weight);
 }
-//___________________________________________________________________
-TH1D *AliCFContainer::ShowProjection(Int_t ivar, Int_t istep) const
-{
-  //
-  // returns 1-D projection along variable ivar at selection step istep
-  //
-  if(istep >= fNStep || istep < 0){
-    AliError("Non-existent selection step, return NULL");
-    return 0x0;
-  }
-  if(ivar >= fNVar || ivar < 0){
-    AliError("Non-existent selection step, return NULL");
-    return 0x0;
-  }
-
-  return fGrid[istep]->Project(ivar);
-}
-//___________________________________________________________________
-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
-  //
-  if(istep >= fNStep || istep < 0){
-    AliError("Non-existent selection step, return NULL");
-    return 0x0;
-  }
-  if(ivar1 >= fNVar || ivar1 < 0 || ivar2 >= fNVar || ivar2 < 0){
-    AliError("Non-existent selection step, return NULL");
-    return 0x0;
-  }
 
-  return fGrid[istep]->Project(ivar1,ivar2);
-}
-//___________________________________________________________________
-TH3D *AliCFContainer::ShowProjection(Int_t ivar1, Int_t ivar2, Int_t ivar3, Int_t istep) const
+//____________________________________________________________________
+TH1* AliCFContainer::Project(Int_t istep, Int_t ivar1, Int_t ivar2, Int_t ivar3) const
 {
   //
-  // returns 3-D projection along variables ivar1,ivar2,ivar3 
+  // returns a projection along variables ivar1 (and ivar2 (and ivar3))
   // at selection step istep
   //
-  if(istep >= fNStep || istep < 0){
-    AliError("Non-existent selection step, return NULL");
-    return 0x0;
-  }
-  if(ivar1 >= fNVar || ivar1 < 0 || 
-     ivar2 >= fNVar || ivar2 < 0 ||
-     ivar3 >= fNVar || ivar3 < 0 ) {
+  if (istep >= fNStep || istep < 0){
     AliError("Non-existent selection step, return NULL");
     return 0x0;
   }
-
   return fGrid[istep]->Project(ivar1,ivar2,ivar3);
 }
-//___________________________________________________________________
-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]
-  //
-  if(istep >= fNStep || istep < 0){
-    AliError("Non-existent selection step, return NULL");
-    return 0x0;
-  }
-  if (ivar >= fNVar || ivar < 0) {
-    AliError("Non-existent variable, return NULL");
-    return 0x0;
-  }
-  return (TH1D*)fGrid[istep]->Slice(ivar,varMin,varMax);
-}
-//___________________________________________________________________
-TH2D *AliCFContainer::ShowSlice(Int_t ivar1, Int_t ivar2, Double_t *varMin, Double_t* varMax, Int_t istep) const
-{
-  //
-  // Make a slice along variables ivar1 and ivar2 at selection level istep in range [varMin,varMax]
-  //
-  if(istep >= fNStep || istep < 0){
-    AliError("Non-existent selection step, return NULL");
-    return 0x0;
-  }
-  if (ivar1 >= fNVar || ivar1 < 0 || ivar2 >= fNVar || ivar2 < 0) {
-    AliError("Non-existent variable, return NULL");
-    return 0x0;
-  }
-  return (TH2D*)fGrid[istep]->Slice(ivar1,ivar2,varMin,varMax);
-}
-//___________________________________________________________________
-TH3D *AliCFContainer::ShowSlice(Int_t ivar1, Int_t ivar2, Int_t ivar3, Double_t *varMin, Double_t* varMax, Int_t istep) const
+
+//____________________________________________________________________
+AliCFContainer* AliCFContainer::MakeSlice(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Bool_t useBins) const
 {
   //
-  // Make a slice along variables ivar1, ivar2and ivar3 at selection level istep in range [varMin,varMax]
+  // Makes a slice along the "nVars" variables defined in the array "vars[nVars]" for all the container steps.
+  // The ranges of ALL the container variables must be defined in the array varMin[GetNVar()] and varMax[GetNVar()]
+  // The function returns a new container of nVars variables.
+  // If useBins=true, varMin and varMax are taken as bin numbers
   //
-  if(istep >= fNStep || istep < 0){
-    AliError("Non-existent selection step, return NULL");
-    return 0x0;
-  }
-  if (ivar1 >= fNVar || ivar1 < 0 || ivar2 >= fNVar || ivar2 < 0 || ivar3 >= fNVar || ivar3 < 0) {
-    AliError("Non-existent variable, return NULL");
-    return 0x0;
-  }
-  return (TH3D*)fGrid[istep]->Slice(ivar1,ivar2,ivar3,varMin,varMax);
+  Int_t* steps = new Int_t[fNStep];
+  for (Int_t iStep=0;iStep<fNStep;iStep++) steps[iStep]=iStep;
+  AliCFContainer* out = MakeSlice(fNStep,steps,nVars,vars,varMin,varMax,useBins);
+  delete [] steps ;
+  return out;
 }
+
 //____________________________________________________________________
-AliCFContainer* AliCFContainer::MakeSlice(Int_t nVars, Int_t* vars, Double_t* varMin, Double_t* varMax) const
+AliCFContainer* AliCFContainer::MakeSlice(Int_t nSteps, const Int_t* steps, 
+					  Int_t nVars, const Int_t* vars, 
+					  const Double_t* varMin, const Double_t* varMax, Bool_t useBins) const
 {
   //
-  // Makes a slice along the "nVars" variables defined in the array vars[nVars].
-  // The ranges of ALL the container variables must be defined in the array varMin[fNVar] and varMax[fNVar]
+  // Makes a slice along the "nVars" variables defined in the array "vars[nVars]" for the given "nSteps" defined in "steps[nSteps]".
+  // The ranges of ALL the container variables must be defined in the array varMin[GetNVar()] and varMax[GetNVar()]
   // The function returns a new container of nVars variables.
+  // If useBins=true, varMin and varMax are taken as bin numbers
   //
 
-  if (nVars < 1 || nVars > fNVar)   AliError("Bad number of dimensions required for the slice");
+  if (nVars < 1 || nVars > GetNVar())   AliError("Bad number of dimensions required for the slice");
+  if (nSteps< 1 || nSteps> fNStep)  AliError("Bad number of steps required for the slice");
+
+  AliInfo(Form("Making a slice in %d dimension(s)",nVars));
+
+  // create the output grids
+  AliCFGridSparse** grids = new AliCFGridSparse*[nSteps] ;
+  for (Int_t iStep=0; iStep<nSteps; iStep++) grids[iStep] = fGrid[steps[iStep]]->MakeSlice(nVars,vars,varMin,varMax,useBins);
+
+  TAxis ** axis = new TAxis*[nVars];
+  for (Int_t iVar=0; iVar<nVars; iVar++) axis[iVar] = ((AliCFGridSparse*)grids[0])->GetGrid()->GetAxis(iVar); //same axis for every grid
 
   //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);
+  for (Int_t iVar=0; iVar<nVars; iVar++) bins[iVar] = axis[iVar]->GetNbins();
+
+  AliCFContainer* out = new AliCFContainer(fName,fTitle,nSteps,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);
+    Int_t nBins = bins[iVar];
+    Double_t *array = new Double_t[nBins+1];
+    for (Int_t iBin=1; iBin<=nBins+1; iBin++) {
+      array[iBin-1] = axis[iVar]->GetBinLowEdge(iBin);
+    }
     out->SetBinLimits(iVar,array);
-    delete 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));
+  //set grid for the given steps
+  for (Int_t iStep=0; iStep<nSteps; iStep++) out->SetGrid(iStep,grids[iStep]);
 
-  delete bins;
+  delete [] bins;
+  delete [] axis ;
+  delete [] grids;
   return out;
 }
 
@@ -305,11 +216,11 @@ Long64_t AliCFContainer::Merge(TCollection* list)
   if (list->IsEmpty())
     return 1;
 
-  TIterator* iter = list->MakeIterator();
+  TIter iter(list);
   TObject* obj;
   
   Int_t count = 0;
-  while ((obj = iter->Next())) {
+  while ((obj = iter())) {
     AliCFContainer* entry = dynamic_cast<AliCFContainer*> (obj);
     if (entry == 0) 
       continue;
@@ -321,47 +232,48 @@ Long64_t AliCFContainer::Merge(TCollection* list)
 }
 
 //____________________________________________________________________
-void AliCFContainer::Add(AliCFContainer* aContainerToAdd, Double_t c)
+void AliCFContainer::Add(const AliCFContainer* aContainerToAdd, Double_t c)
 {
   //
   //add the content of container aContainerToAdd to the current one
   //
-  if( (aContainerToAdd->GetNStep()!=fNStep)
-      ||
-      (aContainerToAdd->GetNVar()!=fNVar)
-      ||
-      (aContainerToAdd->GetNDim()!=fNDim)){
-    AliError("Different number of steps/sensitive variables/grid elements: cannot add the containers");
-    return;
-  }
-  for(Int_t istep=0;istep<fNStep;istep++){
+  if ((aContainerToAdd->GetNStep()      != fNStep)          ||
+      (aContainerToAdd->GetNVar()       != GetNVar())       ||
+      (aContainerToAdd->GetNBinsTotal() != GetNBinsTotal()))
+    {
+      AliError("Different number of steps/sensitive variables/grid elements: cannot add the containers");
+      return;
+    }
+  for (Int_t istep=0; istep<fNStep; istep++) {
     fGrid[istep]->Add(aContainerToAdd->GetGrid(istep),c);
   }
 }
 //____________________________________________________________________
-Float_t AliCFContainer::GetOverFlows( Int_t ivar, Int_t istep) const {
+Float_t AliCFContainer::GetOverFlows( Int_t ivar, Int_t istep, Bool_t exclusive) const {
   //
   // Get overflows in variable var at selection level istep
+  // Set 'exclusive' to true for an exclusive check on variable ivar
   //
   if(istep >= fNStep || istep < 0){
     AliError("Non-existent selection step, return -1");
     return -1.;
   }
-  return fGrid[istep]->GetOverFlows(ivar);
+  return fGrid[istep]->GetOverFlows(ivar,exclusive);
 } 
 //____________________________________________________________________
-Float_t AliCFContainer::GetUnderFlows( Int_t ivar, Int_t istep) const {
+Float_t AliCFContainer::GetUnderFlows( Int_t ivar, Int_t istep, Bool_t exclusive) const {
   //
   // Get underflows in variable var at selection level istep
+  // Set 'exclusive' to true for an exclusive check on variable ivar
   //
   if(istep >= fNStep || istep < 0){
     AliError("Non-existent selection step, return -1");
     return -1.;
   }
-  return fGrid[istep]->GetUnderFlows(ivar);
+  return fGrid[istep]->GetUnderFlows(ivar,exclusive);
 } 
 //____________________________________________________________________
-Float_t AliCFContainer::GetEntries( Int_t istep) const {
+Float_t AliCFContainer::GetEntries(Int_t istep) const {
   //
   // Get total entries in variable var at selection level istep
   //
@@ -371,28 +283,6 @@ Float_t AliCFContainer::GetEntries( Int_t istep) const {
   }
   return fGrid[istep]->GetEntries();
 } 
-//____________________________________________________________________
-Int_t AliCFContainer::GetEmptyBins( Int_t istep) const {
-  //
-  // Get empty bins in variable var at selection level istep
-  //
-  if(istep >= fNStep || istep < 0){
-    AliError("Non-existent selection step, return -1");
-    return -1;
-  }
-  return fGrid[istep]->GetEmptyBins();
-} 
-//____________________________________________________________________
-Int_t AliCFContainer::GetEmptyBins( Int_t istep, Double_t *varMin, Double_t* varMax) const {
-  //
-  // Get empty bins in a range in variable var at selection level istep
-  //
-  if(istep >= fNStep || istep < 0){
-    AliError("Non-existent selection step, return -1");
-    return -1;
-  }
-  return fGrid[istep]->GetEmptyBins(varMin,varMax);
-} 
 //_____________________________________________________________________
 Double_t AliCFContainer::GetIntegral( Int_t istep) const 
 {
@@ -405,52 +295,43 @@ Double_t AliCFContainer::GetIntegral( Int_t istep) const
   }
   return fGrid[istep]->GetIntegral();
 }
+
 //_____________________________________________________________________
-Double_t AliCFContainer::GetIntegral( Int_t istep, Double_t *varMin, Double_t* varMax ) const 
-{
-  //
-  // Get Integral over the grid in a range at selection level istep
-  //
-  if(istep >= fNStep || istep < 0){
-    AliError("Non-existent selection step, return -1");
-    return -1.;
-  }
-  return fGrid[istep]->GetIntegral(varMin,varMax);
-}
-//_____________________________________________________________________
-void AliCFContainer::SetRangeUser(Int_t ivar, Double_t varMin, Double_t varMax, Int_t istep) 
+void AliCFContainer::SetRangeUser(Int_t ivar, Double_t varMin, Double_t varMax, Bool_t useBins) const
 {
   //
-  // set axis range at step istep
+  // set axis range for variable ivar
+  // put useBins=kTRUE if you want to pass bin numbers instead of 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 ;
-  }
-  if (ivar >= fNVar || ivar < 0){
+  if (ivar >= GetNVar() || ivar < 0){
     AliError("Non-existent selection var");
     return ;
   }
-  ((AliCFGridSparse*)fGrid[istep])->SetRangeUser(ivar,varMin,varMax);
+  for (Int_t iStep=0; iStep<GetNStep(); iStep++) fGrid[iStep]->SetRangeUser(ivar,varMin,varMax,useBins);
 }
 
 //_____________________________________________________________________
-void AliCFContainer::SetRangeUser(Double_t* varMin, Double_t* varMax, Int_t istep) 
+void AliCFContainer::SetRangeUser(const Double_t* varMin, const Double_t* varMax, Bool_t useBins) const
 {
   //
-  // set all axis ranges at step istep according to varMin and varMax values
+  // set all axis ranges according to arrays varMin and varMax
+  // put useBins=kTRUE if you want to pass bin numbers instead of 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 ;
+  for (Int_t iStep=0; iStep<GetNStep(); iStep++) fGrid[iStep]->SetRangeUser(varMin,varMax,useBins);
+}
+
+//_____________________________________________________________________
+void AliCFContainer::Print(const Option_t*) const {
+  AliInfo("====================================================================================");
+  AliInfo(Form("AliCFContainer : name = %s   title = %s",GetName(),GetTitle()));
+  AliInfo(Form("number of steps \t %d",GetNStep()));
+  for (Int_t iStep=0;iStep<GetNStep();iStep++) AliInfo(Form("step %d \t -> %s",iStep,GetStepTitle(iStep)));
+  AliInfo(Form("number of variables \t %d",GetNVar()));
+  for (Int_t iVar=0;iVar<GetNVar();iVar++) {
+    Double_t *binLimits = new Double_t[GetNBins(iVar)+1];
+    GetBinLimits(iVar,binLimits);
+    AliInfo(Form("variable %d \t -> %s : %d bins in [%f,%f]",iVar,GetVarTitle(iVar),GetNBins(iVar),binLimits[0],binLimits[GetNBins(iVar)]));
+    delete[] binLimits;
   }
-  ((AliCFGridSparse*)fGrid[istep])->SetRangeUser(varMin,varMax);
+  AliInfo("====================================================================================");
 }