// 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) :
// The grids
fGrid = new AliCFGridSparse*[fNStep]; //the grids at the various selection steps
- char gname[100];
for (Int_t istep=0; istep<fNStep; istep++) {
- sprintf(gname,"%s%s%i",GetName(),"_SelStep", istep);
- fGrid[istep] = new AliCFGridSparse(gname,title,nVarIn,nBinIn);
+ 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));
}
//____________________________________________________________________
}
fGrid[istep]->Fill(var,weight);
}
-//___________________________________________________________________
-TH1D *AliCFContainer::Project(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 >= GetNVar() || ivar < 0){
- AliError("Non-existent variable, return NULL");
- return 0x0;
- }
- return fGrid[istep]->Project(ivar);
-}
-//___________________________________________________________________
-TH2D *AliCFContainer::Project(Int_t ivar1, Int_t ivar2, Int_t istep) const
-{
- //
- // returns 2-D projection along variables ivar1,ivar2 at selection step istep
- //
- if(istep >= fNStep || istep < 0){
- AliError("Non-existent selection step, return NULL");
- return 0x0;
- }
- if(ivar1 >= GetNVar() || ivar1 < 0 || ivar2 >= GetNVar() || ivar2 < 0){
- AliError("Non-existent variable, return NULL");
- return 0x0;
- }
-
- return fGrid[istep]->Project(ivar1,ivar2);
-}
-//___________________________________________________________________
-TH3D *AliCFContainer::Project(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){
+ if (istep >= fNStep || istep < 0){
AliError("Non-existent selection step, return NULL");
return 0x0;
}
- if(ivar1 >= GetNVar() || ivar1 < 0 ||
- ivar2 >= GetNVar() || ivar2 < 0 ||
- ivar3 >= GetNVar() || ivar3 < 0 ) {
- AliError("Non-existent variable, return NULL");
- return 0x0;
- }
-
return fGrid[istep]->Project(ivar1,ivar2,ivar3);
}
-//___________________________________________________________________
-TH1D *AliCFContainer::ShowSlice(Int_t ivar, const Double_t *varMin, const Double_t* varMax, Int_t istep, Bool_t useBins) const
-{
- //
- // Make a slice along variable ivar at selection level istep in range [varMin,varMax]
- // 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 (ivar >= GetNVar() || ivar < 0) {
- AliError("Non-existent variable, return NULL");
- return 0x0;
- }
- return (TH1D*)fGrid[istep]->Slice(ivar,varMin,varMax,useBins);
-}
-//___________________________________________________________________
-TH2D *AliCFContainer::ShowSlice(Int_t ivar1, Int_t ivar2, const Double_t *varMin, const Double_t* varMax, Int_t istep, Bool_t useBins) const
-{
- //
- // Make a slice along variables ivar1 and ivar2 at selection level istep in range [varMin,varMax]
- // 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 >= GetNVar() || ivar1 < 0 || ivar2 >= GetNVar() || ivar2 < 0) {
- AliError("Non-existent variable, return NULL");
- return 0x0;
- }
- return (TH2D*)fGrid[istep]->Slice(ivar1,ivar2,varMin,varMax,useBins);
-}
-//___________________________________________________________________
-TH3D *AliCFContainer::ShowSlice(Int_t ivar1, Int_t ivar2, Int_t ivar3, const Double_t *varMin, const Double_t* varMax, Int_t istep, Bool_t useBins) const
-{
- //
- // Make a slice along variables ivar1, ivar2and ivar3 at selection level istep in range [varMin,varMax]
- // 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 >= GetNVar() || ivar1 < 0 || ivar2 >= GetNVar() || ivar2 < 0 || ivar3 >= GetNVar() || ivar3 < 0) {
- AliError("Non-existent variable, return NULL");
- return 0x0;
- }
- return (TH3D*)fGrid[istep]->Slice(ivar1,ivar2,ivar3,varMin,varMax,useBins);
-}
+
//____________________________________________________________________
AliCFContainer* AliCFContainer::MakeSlice(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Bool_t useBins) const
{
//
Int_t* steps = new Int_t[fNStep];
for (Int_t iStep=0;iStep<fNStep;iStep++) steps[iStep]=iStep;
- AliCFContainer* out = MakeSlice(nVars,vars,varMin,varMax,fNStep,steps,useBins);
+ AliCFContainer* out = MakeSlice(fNStep,steps,nVars,vars,varMin,varMax,useBins);
delete [] steps ;
return out;
}
//____________________________________________________________________
-AliCFContainer* AliCFContainer::MakeSlice(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Int_t nSteps, const Int_t* steps, Bool_t useBins) 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]" for the given "nSteps" defined in "steps[nSteps]".
// create the output grids
AliCFGridSparse** grids = new AliCFGridSparse*[nSteps] ;
- for (Int_t iStep=0; iStep<nSteps; iStep++) grids[iStep] = fGrid[steps[iStep]]->Project(nVars,vars,varMin,varMax,useBins);
-
+ 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
}
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
{
}
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 (istep >= fNStep || istep < 0){
- AliError("Non-existent selection step");
- return ;
- }
if (ivar >= GetNVar() || ivar < 0){
AliError("Non-existent selection var");
return ;
}
- 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 (istep >= fNStep || istep < 0){
- AliError("Non-existent selection step");
- return ;
- }
- ((AliCFGridSparse*)fGrid[istep])->SetRangeUser(varMin,varMax);
+ for (Int_t iStep=0; iStep<GetNStep(); iStep++) fGrid[iStep]->SetRangeUser(varMin,varMax,useBins);
}
//_____________________________________________________________________
{
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);
AliCFContainer(const AliCFContainer& c);
AliCFContainer& operator=(const AliCFContainer& corr);
virtual void Print(const Option_t*) const ;
- //virtual void GetBinCenters(const Int_t *ibin, const Double_t *binCenter) const {return fGrid[0]->GetBinCenters(ibin,binCenter);}
- //virtual void GetBinSizes(const Int_t *ibin, const Double_t *binSizes) const {return fGrid[0]->GetBinSizes(ibin,binSizes);}
-
- //probably not needed anymore
- //virtual Int_t GetBinIndex(const Int_t *ibin) const {return fGrid[0]->GetBinIndex(ibin);}
- //virtual void GetBinIndex(Int_t iel, const Int_t *ibin) const {return fGrid[0]->GetBinIndex(iel,ibin);}
- //virtual Int_t GetBinIndex(Int_t ivar, Int_t ind) const {return fGrid[0]->GetBinIndex(ivar,ind);}
-
virtual TAxis * GetAxis(Int_t ivar, Int_t istep) const {return fGrid[istep]->GetAxis(ivar);}
virtual void SetVarTitle (Int_t ivar, const Char_t* title) ;
virtual void SetStepTitle(Int_t istep, const Char_t* title) ;
virtual Float_t GetUnderFlows(Int_t var,Int_t istep,Bool_t excl=kFALSE) const ;
virtual Float_t GetEntries (Int_t istep) const ;
virtual Long_t GetEmptyBins(Int_t istep) const {return fGrid[istep]->GetEmptyBins();}
- //virtual Int_t GetEmptyBins(Int_t istep, Double_t *varMin,Double_t *varMax) const ;
virtual Double_t GetIntegral (Int_t istep) const ;
- //virtual Double_t GetIntegral (Int_t istep, Double_t *varMin,Double_t *varMax) const ;
-
//basic operations
virtual void Add(const AliCFContainer* aContainerToAdd, Double_t c=1.);
virtual Long64_t Merge(TCollection* list);
- virtual TH1D* ShowProjection( Int_t ivar, Int_t istep) const {return Project(ivar ,istep);}
- virtual TH2D* ShowProjection( Int_t ivar1, Int_t ivar2, Int_t istep) const {return Project(ivar1,ivar2 ,istep);}
- virtual TH3D* ShowProjection( Int_t ivar1, Int_t ivar2,Int_t ivar3, Int_t istep) const {return Project(ivar1,ivar2,ivar3,istep);}
- virtual TH1D* Project( Int_t ivar, Int_t istep) const;
- virtual TH2D* Project( Int_t ivar1, Int_t ivar2, Int_t istep) const;
- virtual TH3D* Project( Int_t ivar1, Int_t ivar2,Int_t ivar3, Int_t istep) const;
-
- virtual TH1D* ShowSlice(Int_t ivar, const Double_t *varMin, const Double_t *varMax, Int_t istep, Bool_t useBins=0) const ;
- virtual TH2D* ShowSlice(Int_t ivar1, Int_t ivar2, const Double_t *varMin, const Double_t *varMax, Int_t istep, Bool_t useBins=0) const ;
- virtual TH3D* ShowSlice(Int_t ivar1, Int_t ivar2, Int_t ivar3, const Double_t *varMin, const Double_t *varMax, Int_t istep, Bool_t useBins=0) const ;
- virtual AliCFContainer* MakeSlice(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Bool_t useBins=0) const ;
- virtual AliCFContainer* MakeSlice(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Int_t nStep, const Int_t* steps, Bool_t useBins=0) const ;
+ virtual TH1* Project (Int_t istep, Int_t ivar1, Int_t ivar2=-1 ,Int_t ivar3=-1) const;
+ virtual AliCFContainer* MakeSlice(Int_t nVars, const Int_t* vars, const Double_t* varMin=0x0, const Double_t* varMax=0x0, Bool_t useBins=0) const ;
+ virtual AliCFContainer* MakeSlice(Int_t nStep, const Int_t* steps,
+ Int_t nVars, const Int_t* vars, const Double_t* varMin=0x0, const Double_t* varMax=0x0,
+ Bool_t useBins=0) const ;
virtual void Smooth(Int_t istep) {GetGrid(istep)->Smooth();}
- 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 SetRangeUser(Int_t ivar, Double_t varMin, Double_t varMax, Bool_t useBins=kFALSE) const ;
+ virtual void SetRangeUser(const Double_t* varMin, const Double_t* varMax, Bool_t useBins=kFALSE) const ;
+
virtual void SetGrid(Int_t step, AliCFGridSparse* grid) {if (fGrid[step]) delete fGrid[step]; fGrid[step]=grid;}
virtual AliCFGridSparse * GetGrid(Int_t istep) const {return fGrid[istep];};
virtual void Scale(Double_t factor) const;
+
+ /**** TO BE REMOVED SOON ******/
+ virtual TH1D* ShowProjection( Int_t ivar, Int_t istep) const {return (TH1D*)Project(istep,ivar);}
+ virtual TH2D* ShowProjection( Int_t ivar1, Int_t ivar2, Int_t istep) const {return (TH2D*)Project(istep,ivar1,ivar2);}
+ virtual TH3D* ShowProjection( Int_t ivar1, Int_t ivar2,Int_t ivar3, Int_t istep) const {return (TH3D*)Project(istep,ivar1,ivar2,ivar3);}
private:
Int_t fNStep; //number of selection steps
AliInfo(Form(" The Average Efficiency = %f ",val));
return val;
}
-//_____________________________________________________________________
-// Double_t AliCFEffGrid::GetAverage(const Double_t *varMin, const Double_t* varMax ) const
-// {
-// //
-// // Get ave efficiency in a range
-// // (may not work properly, should be modified)
-
-// Double_t val=0;
-// Int_t *indexMin = new Int_t[GetNVar()];
-// Int_t *indexMax = new Int_t[GetNVar()];
-// Int_t *index = new Int_t[GetNVar()];
-
-// //Find out the min and max bins
-
-// for(Int_t i=0;i<GetNVar();i++){
-// Double_t xmin=varMin[i]; // the min values
-// Double_t xmax=varMax[i]; // the max values
-// Int_t nbins = GetNBins(i)+1;
-// // Double_t *bins = new Double_t[nbins];
-// // for (Int_t ibin =0; ibin<nbins; ibin++) {
-// // bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
-// // }
-// bins = GetBinLimits(i);
-// indexMin[i] = TMath::BinarySearch(nbins,bins,xmin);
-// indexMax[i] = TMath::BinarySearch(nbins,bins,xmax);
-// if(xmax>=bins[nbins-1]){
-// indexMax[i]=indexMax[i]-1;
-// }
-// delete [] bins;
-// }
-
-// Double_t valnum=0;
-// Double_t valden=0;
-// for (Int_t i=0; i<fNDim; i++) {
-// for (Int_t j=0; j<GetNVar(); j++) index[j]=GetBinIndex(j,i);
-// Bool_t isIn=kTRUE;
-// for (Int_t j=0;j<GetNVar();j++) {
-// if(!(index[j]>=indexMin[j] && index[j]<=indexMax[j]))isIn=kFALSE;
-// }
-// if(isIn){
-// valnum+=GetNum()->GetElement(i);
-// valden+=GetDen()->GetElement(i);
-// }
-// }
-// delete [] index;
-// delete [] indexMin;
-// delete [] indexMax;
-// if(valden>0)val=valnum/valden;
-// AliInfo(Form(" the Average Efficiency = %f ",val));
-// return val;
-// }
-//____________________________________________________________________
-// void AliCFEffGrid::Copy(TObject& eff) const
-// {
-// //
-// // copy function
-// //
-// Copy(eff);
-// AliCFEffGrid& target = (AliCFEffGrid &) eff;
-
-// target.fSelNum=fSelNum;
-// target.fSelDen=fSelDen;
-// if(fContainer)
-// target.fContainer=fContainer;
-// }
-//___________________________________________________________________
-TH1D *AliCFEffGrid::Project(Int_t ivar) const
-{
- //
- // Make a 1D projection along variable ivar
- //
-
- if (fSelNum<0 || fSelDen<0) {
- AliError("You must call CalculateEfficiency() first !");
- return 0x0;
- }
- const Int_t nDim = 1 ;
- Int_t dim[nDim] = {ivar} ;
- THnSparse* hNum = ((AliCFGridSparse*)GetNum())->GetGrid()->Projection(nDim,dim);
- THnSparse* hDen = ((AliCFGridSparse*)GetDen())->GetGrid()->Projection(nDim,dim);
- THnSparse* ratio = (THnSparse*)hNum->Clone();
- ratio->Divide(hNum,hDen,1.,1.,"B");
- delete hNum; delete hDen;
- TH1D* h = ratio->Projection(0);
- h->SetXTitle(GetVarTitle(ivar));
- h->SetName(Form("%s_proj-%s",GetName(),GetVarTitle(ivar)));
- h->SetTitle(Form("%s projected on %s",GetTitle(),GetVarTitle(ivar)));
- return h ;
-}
//___________________________________________________________________
-TH2D *AliCFEffGrid::Project(Int_t ivar1,Int_t ivar2) const
+TH1* AliCFEffGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
{
//
- // Make a 2D projection along variable ivar1,ivar2
- //
-
- if (fSelNum<0 || fSelDen<0) {
- AliError("You must call CalculateEfficiency() first !");
- return 0x0;
- }
- const Int_t nDim = 2 ;
- Int_t dim[nDim] = {ivar1,ivar2} ;
- THnSparse* hNum = ((AliCFGridSparse*)GetNum())->GetGrid()->Projection(nDim,dim);
- THnSparse* hDen = ((AliCFGridSparse*)GetDen())->GetGrid()->Projection(nDim,dim);
- THnSparse* ratio = (THnSparse*)hNum->Clone();
- ratio->Divide(hNum,hDen,1.,1.,"B");
- delete hNum; delete hDen;
- TH2D* h = ratio->Projection(1,0);
- h->SetXTitle(GetVarTitle(ivar1));
- h->SetYTitle(GetVarTitle(ivar2));
- h->SetName(Form("%s_proj-%s,%s",GetName(),GetVarTitle(ivar1),GetVarTitle(ivar2)));
- h->SetTitle(Form("%s projected on %s-%s",GetTitle(),GetVarTitle(ivar1),GetVarTitle(ivar2)));
- return h;
-}
-//___________________________________________________________________
-TH3D *AliCFEffGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
-{
- //
- // Make a 3D projection along variable ivar1,ivar2,ivar3
+ // Make a projection along variable ivar1 (and ivar2 (and ivar3))
//
if (fSelNum<0 || fSelDen<0) {
}
const Int_t nDim = 3 ;
Int_t dim[nDim] = {ivar1,ivar2,ivar3} ;
- THnSparse* hNum = ((AliCFGridSparse*)GetNum())->GetGrid()->Projection(nDim,dim);
- THnSparse* hDen = ((AliCFGridSparse*)GetDen())->GetGrid()->Projection(nDim,dim);
- THnSparse* ratio = (THnSparse*)hNum->Clone();
- ratio->Divide(hNum,hDen,1.,1.,"B");
- delete hNum; delete hDen;
- TH3D* h = ratio->Projection(0,1,2);
- h->SetXTitle(GetVarTitle(ivar1));
- h->SetYTitle(GetVarTitle(ivar2));
- h->SetZTitle(GetVarTitle(ivar3));
- h->SetName(Form("%s_proj-%s,%s,%s",GetName(),GetVarTitle(ivar1),GetVarTitle(ivar2),GetVarTitle(ivar3)));
- h->SetTitle(Form("%s projected on %s-%s-%s",GetTitle(),GetVarTitle(ivar1),GetVarTitle(ivar2),GetVarTitle(ivar3)));
- return h;
+
+ THnSparse *hNum, *hDen, *ratio;
+ TH1* h ;
+
+ if (ivar3<0) {
+ if (ivar2<0) {
+ hNum = ((AliCFGridSparse*)GetNum())->GetGrid()->Projection(nDim-2,dim);
+ hDen = ((AliCFGridSparse*)GetDen())->GetGrid()->Projection(nDim-2,dim);
+ ratio = (THnSparse*)hNum->Clone();
+ ratio->Divide(hNum,hDen,1.,1.,"B");
+ h = ratio->Projection(0);
+ }
+ else{
+ hNum = ((AliCFGridSparse*)GetNum())->GetGrid()->Projection(nDim-1,dim);
+ hDen = ((AliCFGridSparse*)GetDen())->GetGrid()->Projection(nDim-1,dim);
+ ratio = (THnSparse*)hNum->Clone();
+ ratio->Divide(hNum,hDen,1.,1.,"B");
+ h = ratio->Projection(1,0);
+ }
+ }
+ else {
+ hNum = ((AliCFGridSparse*)GetNum())->GetGrid()->Projection(nDim,dim);
+ hDen = ((AliCFGridSparse*)GetDen())->GetGrid()->Projection(nDim,dim);
+ ratio = (THnSparse*)hNum->Clone();
+ ratio->Divide(hNum,hDen,1.,1.,"B");
+ h = ratio->Projection(0,1,2);
+ }
+
+ delete hNum; delete hDen; delete ratio;
+ return h ;
}
//___________________________________________________________________
-AliCFEffGrid* AliCFEffGrid::MakeSlice(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Int_t numStep, Int_t denStep, Bool_t useBins) const {
+AliCFEffGrid* AliCFEffGrid::MakeSlice(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]" for all the container steps.
- // The ranges of ALL the container variables must be defined in the array varMin[fNVar] and varMax[fNVar].
- // This function returns the efficiency relative to this new 'sliced' container, between steps defined in numStep and denStep
- // If useBins=true, varMin and varMax are taken as bin numbers
+ // returns a slice of the efficiency grid (slice is actually done on the container, and efficiency recomputed)
//
AliCFContainer* cont = fContainer->MakeSlice(nVars,vars,varMin,varMax,useBins);
AliCFEffGrid * eff = new AliCFEffGrid(Form("%s_sliced",GetName()), Form("%s_sliced",GetTitle()), *cont);
- eff->CalculateEfficiency(numStep,denStep);
+ eff->CalculateEfficiency(fSelNum,fSelDen);
return eff;
}
public:
AliCFEffGrid();
AliCFEffGrid(const Char_t* name,const Char_t* title, const Int_t nVarIn, const Int_t* nBinIn);
- AliCFEffGrid(const Char_t* name,const Char_t* title,const AliCFContainer &c);
+ AliCFEffGrid(const Char_t* name,const Char_t* title, const AliCFContainer &c);
virtual ~AliCFEffGrid();
AliCFEffGrid(const AliCFEffGrid& eff);
AliCFEffGrid& operator=(const AliCFEffGrid& eff);
virtual Double_t GetAverage() const ;
- //virtual Double_t GetAverage(const Double_t *varMin, const Double_t *varMax) const {AliInfo("to be implemented properly"); return 0.;}
virtual Int_t GetSelNumStep() const {return fSelNum;};
virtual Int_t GetSelDenStep() const {return fSelDen;};
- virtual TH1D* Project( Int_t ivar) const;
- virtual TH2D* Project( Int_t ivar1, Int_t ivar2) const;
- virtual TH3D* Project( Int_t ivar1, Int_t ivar2,Int_t ivar3) const;
- virtual AliCFEffGrid* Project(Int_t,const Int_t*, const Double_t*, const Double_t*,Bool_t) const {AliWarning("Function not to be used"); return 0x0;}
- virtual AliCFEffGrid* MakeSlice(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Int_t numStep, Int_t denStep, Bool_t useBins=0) const;
+ virtual TH1* Project(Int_t ivar1, Int_t ivar2=-1,Int_t ivar3=-1) const;
+ virtual AliCFGridSparse* Project(Int_t, const Int_t*, const Double_t*, const Double_t*, Bool_t) const {AliWarning("should not be used"); return 0x0;}
+ virtual AliCFEffGrid* MakeSlice(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Bool_t useBins=0) const;
//Efficiency calculation
virtual void CalculateEfficiency(Int_t istep1, Int_t istep2, Option_t *option ="B" /*binomial*/);
virtual AliCFGridSparse* GetDen() const {return fContainer->GetGrid(fSelDen);};
virtual void SetContainer(const AliCFContainer &c) {fContainer=&c;};
- //basic operations
- /* virtual void Copy(TObject& eff) const; */
-
private:
const AliCFContainer *fContainer; //pointer to the input AliContainer
Int_t fSelNum; //numerator selection step
};
#endif
-
}
//___________________________________________________________________
-TH1D *AliCFGridSparse::Project(Int_t ivar) const
-{
- //
- // Make a 1D projection along variable ivar
- //
-
- TH1D *hist=fData->Projection(ivar);
- hist->SetXTitle(GetVarTitle(ivar));
- hist->SetName(Form("%s_proj-%s",GetName(),GetVarTitle(ivar)));
- hist->SetTitle(Form("%s: projection on %s",GetTitle(),GetVarTitle(ivar)));
- for (Int_t iBin=1; iBin<=GetNBins(ivar); iBin++) {
- TString binLabel = GetAxis(ivar)->GetBinLabel(iBin) ;
- if (binLabel.CompareTo("") != 0) hist->GetXaxis()->SetBinLabel(iBin,binLabel);
- }
- return hist;
-}
-//___________________________________________________________________
-TH2D *AliCFGridSparse::Project(Int_t ivar1, Int_t ivar2) const
-{
- //
- // Make a 2D projection along variables ivar1 & ivar2
- //
-
- TH2D *hist=fData->Projection(ivar2,ivar1); //notice inverted axis (THnSparse uses TH3 2d-projection convention...)
- hist->SetXTitle(GetVarTitle(ivar1));
- hist->SetYTitle(GetVarTitle(ivar2));
- hist->SetName(Form("%s_proj-%s,%s",GetName(),GetVarTitle(ivar1),GetVarTitle(ivar2)));
- hist->SetTitle(Form("%s: projection on %s-%s",GetTitle(),GetVarTitle(ivar1),GetVarTitle(ivar2)));
- for (Int_t iBin=1; iBin<=GetNBins(ivar1); iBin++) {
- TString binLabel = GetAxis(ivar1)->GetBinLabel(iBin) ;
- if (binLabel.CompareTo("") != 0) hist->GetXaxis()->SetBinLabel(iBin,binLabel);
- }
- for (Int_t iBin=1; iBin<=GetNBins(ivar2); iBin++) {
- TString binLabel = GetAxis(ivar2)->GetBinLabel(iBin) ;
- if (binLabel.CompareTo("") != 0) hist->GetYaxis()->SetBinLabel(iBin,binLabel);
- }
- return hist;
-}
-//___________________________________________________________________
-TH3D *AliCFGridSparse::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
-{
- //
- // Make a 3D projection along variables ivar1 & ivar2 & ivar3
- //
-
- TH3D *hist=fData->Projection(ivar1,ivar2,ivar3);
- hist->SetXTitle(GetVarTitle(ivar1));
- hist->SetYTitle(GetVarTitle(ivar2));
- hist->SetZTitle(GetVarTitle(ivar3));
- hist->SetName(Form("%s_proj-%s,%s,%s",GetName(),GetVarTitle(ivar1),GetVarTitle(ivar2),GetVarTitle(ivar3)));
- hist->SetTitle(Form("%s: projection on %s-%s-%s",GetTitle(),GetVarTitle(ivar1),GetVarTitle(ivar2),GetVarTitle(ivar3)));
- for (Int_t iBin=1; iBin<=GetNBins(ivar1); iBin++) {
- TString binLabel = GetAxis(ivar1)->GetBinLabel(iBin) ;
- if (binLabel.CompareTo("") != 0) hist->GetXaxis()->SetBinLabel(iBin,binLabel);
- }
- for (Int_t iBin=1; iBin<=GetNBins(ivar2); iBin++) {
- TString binLabel = GetAxis(ivar2)->GetBinLabel(iBin) ;
- if (binLabel.CompareTo("") != 0) hist->GetYaxis()->SetBinLabel(iBin,binLabel);
- }
- for (Int_t iBin=1; iBin<=GetNBins(ivar3); iBin++) {
- TString binLabel = GetAxis(ivar3)->GetBinLabel(iBin) ;
- if (binLabel.CompareTo("") != 0) hist->GetZaxis()->SetBinLabel(iBin,binLabel);
- }
- return hist;
-}
-
-//___________________________________________________________________
-AliCFGridSparse* AliCFGridSparse::Project(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Bool_t useBins) const
+AliCFGridSparse* AliCFGridSparse::MakeSlice(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Bool_t useBins) const
{
//
// projects the grid on the nVars dimensions defined in vars.
THnSparse* clone = ((THnSparse*)fData->Clone());
if (varMin && varMax) {
for (Int_t iAxis=0; iAxis<GetNVar(); iAxis++) {
- if (useBins) clone->GetAxis(iAxis)->SetRange((Int_t)varMin[iAxis],(Int_t)varMax[iAxis]);
- else clone->GetAxis(iAxis)->SetRangeUser(varMin[iAxis],varMax[iAxis]);
+ SetAxisRange(clone->GetAxis(iAxis),varMin[iAxis],varMax[iAxis],useBins);
}
}
else AliInfo("Keeping same axis ranges");
out->SetGrid(clone->Projection(nVars,vars));
delete [] bins;
+ delete clone;
return out;
}
return (GetNBinsTotal() - GetNFilledBins()) ;
}
-//_____________________________________________________________________
-// Int_t AliCFGridSparse::GetEmptyBins( Double_t *varMin, Double_t* varMax ) const
-// {
-// //
-// // Get empty bins in a range specified by varMin and varMax
-// //
-
-// Int_t *indexMin = new Int_t[GetNVar()];
-// Int_t *indexMax = new Int_t[GetNVar()];
-
-// //Find out the min and max bins
-
-// for (Int_t i=0;i<GetNVar();i++) {
-// Double_t xmin=varMin[i]; // the min values
-// Double_t xmax=varMax[i]; // the min values
-// Int_t nbins = fData->GetAxis(i)->GetNbins()+1;
-// Double_t *bins=new Double_t[nbins];
-// for(Int_t ibin =0;ibin<nbins;ibin++){
-// bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
-// }
-// indexMin[i] = TMath::BinarySearch(nbins,bins,xmin);
-// indexMax[i] = TMath::BinarySearch(nbins,bins,xmax);
-// delete [] bins;
-// }
-
-// Int_t val=0;
-// for(Int_t i=0;i<fNDim;i++){
-// for (Int_t j=0;j<GetNVar();j++)fIndex[j]=GetBinIndex(j,i);
-// Bool_t isIn=kTRUE;
-// for (Int_t j=0;j<GetNVar();j++){
-// if(!(fIndex[j]>=indexMin[j] && fIndex[j]<=indexMax[j]))isIn=kFALSE;
-// }
-// if(isIn && GetElement(i)<=0)val++;
-// }
-// AliInfo(Form(" the empty bins = %i ",val));
-
-// delete [] indexMin;
-// delete [] indexMax;
-// return val;
-// }
-
//____________________________________________________________________
Int_t AliCFGridSparse::CheckStats(Double_t thr) const
{
return fData->ComputeIntegral();
}
-//_____________________________________________________________________
-// Double_t AliCFGridSparse::GetIntegral(Int_t *binMin, Int_t* binMax ) const
-// {
-// //
-// // Get Integral in a range of bin indeces (extremes included)
-// //
-
-// Double_t val=0;
-
-// for(Int_t i=0;i<GetNVar();i++){
-// if(binMin[i]<1)binMin[i]=1;
-// if(binMax[i]>fNVarBins[i])binMax[i]=fNVarBins[i];
-// if((binMin[i]>binMax[i])){
-// AliInfo(Form(" Bin indices in variable %i in reverse order, please check!", i));
-// return val;
-// }
-// }
-// val=GetSum(0,binMin,binMax);
-
-// return val;
-// }
-
-//_____________________________________________________________________
-// Double_t AliCFGridSparse::GetIntegral(Double_t *varMin, Double_t* varMax ) const
-// {
-// //
-// // Get Integral in a range (extremes included)
-// //
-
-// Int_t *indexMin=new Int_t[GetNVar()];
-// Int_t *indexMax=new Int_t[GetNVar()];
-
-// //Find out the min and max bins
-
-// for(Int_t i=0;i<GetNVar();i++){
-// Double_t xmin=varMin[i]; // the min values
-// Double_t xmax=varMax[i]; // the min values
-// Int_t nbins=fNVarBins[i]+1;
-// Double_t *bins=new Double_t[nbins];
-// for(Int_t ibin =0;ibin<nbins;ibin++){
-// bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
-// }
-// indexMin[i] = TMath::BinarySearch(nbins,bins,xmin);
-// indexMax[i] = TMath::BinarySearch(nbins,bins,xmax);
-// delete [] bins;
-// }
-
-// //move to the TH/THnSparse convention in N-dim bin numbering
-// for(Int_t i=0;i<GetNVar();i++){
-// indexMin[i]+=1;
-// indexMax[i]+=1;
-// }
-
-// Double_t val=GetIntegral(indexMin,indexMax);
-
-// delete [] indexMin;
-// delete [] indexMax;
-
-// return val;
-// }
-
-// //_____________________________________________________________________
-// Double_t AliCFGridSparse::GetSum(Int_t ivar, Int_t *binMin, Int_t* binMax) const
-// {
-// //
-// // recursively add over nested loops....
-// //
-
-// static Double_t val;
-// if (ivar==0) val=0.;
-// for(Int_t ibin=binMin[ivar]-1 ; ibin<=binMax[ivar]-1 ; ibin++){
-// //-1 is to move from TH/ThnSparse N-dim bin convention to one in AliCFFrame
-// fIndex[ivar]=ibin;
-// if(ivar<GetNVar()-1) {
-// val=GetSum(ivar+1,binMin,binMax);
-// }
-// else {
-// Int_t iel=GetBinIndex(fIndex);
-// val+=GetElement(iel);
-// }
-// }
-
-// return val;
-// }
-
//____________________________________________________________________
Long64_t AliCFGridSparse::Merge(TCollection* list)
{
}
//____________________________________________________________________
-TH1D* AliCFGridSparse::Slice(Int_t iVar, const Double_t *varMin, const Double_t *varMax, Bool_t useBins) const
+TH1* AliCFGridSparse::Slice(Int_t iVar1, Int_t iVar2, Int_t iVar3, const Double_t *varMin, const Double_t *varMax, Bool_t useBins) const
{
//
- // return a slice (1D-projection) on variable iVar while axis ranges are defined with varMin,varMax
+ // return a slice on variables iVar1 (and optionnally iVar2 (and iVar3)) while axis ranges are defined with varMin,varMax
// arrays varMin and varMax contain the min and max values of each variable.
// therefore varMin and varMax must have their dimensions equal to GetNVar()
// If useBins=true, varMin and varMax are taken as bin numbers
-
+ // if varmin or varmax point to null, all the range is taken, including over- and underflows
+
THnSparse* clone = (THnSparse*)fData->Clone();
- for (Int_t iAxis=0; iAxis<GetNVar(); iAxis++) {
- if (useBins) clone->GetAxis(iAxis)->SetRange((Int_t)varMin[iAxis],(Int_t)varMax[iAxis]);
- else clone->GetAxis(iAxis)->SetRangeUser(varMin[iAxis],varMax[iAxis]);
+ if (varMin != 0x0 && varMax != 0x0) {
+ for (Int_t iAxis=0; iAxis<GetNVar(); iAxis++) SetAxisRange(clone->GetAxis(iAxis),varMin[iAxis],varMax[iAxis],useBins);
}
- TH1D* projection = 0x0 ;
+ TH1* projection = 0x0 ;
+ TString name,title;
+ GetProjectionName (name ,iVar1,iVar2,iVar3);
+ GetProjectionTitle(title,iVar1,iVar2,iVar3);
- TObject* objInMem = gROOT->FindObject(Form("%s_proj_%d",clone->GetName(),iVar)) ;
- if (objInMem) {
- TString name(objInMem->ClassName());
- if (name.CompareTo("TH1D")==0) projection = (TH1D*) objInMem ;
- else projection = clone->Projection(iVar);
+ if (iVar3<0) {
+ if (iVar2<0) {
+ if (iVar1 >= GetNVar() || iVar1 < 0 ) {
+ AliError("Non-existent variable, return NULL");
+ return 0x0;
+ }
+ projection = (TH1D*)clone->Projection(iVar1);
+ projection->SetTitle(Form("%s_proj-%s",GetTitle(),GetVarTitle(iVar1)));
+ for (Int_t iBin=1; iBin<=GetNBins(iVar1); iBin++) {
+ TString binLabel = GetAxis(iVar1)->GetBinLabel(iBin) ;
+ if (binLabel.CompareTo("") != 0) projection->GetXaxis()->SetBinLabel(iBin,binLabel);
+ }
+ }
+ else {
+ if (iVar1 >= GetNVar() || iVar1 < 0 ||
+ iVar2 >= GetNVar() || iVar2 < 0 ) {
+ AliError("Non-existent variable, return NULL");
+ return 0x0;
+ }
+ projection = (TH2D*)clone->Projection(iVar2,iVar1);
+ for (Int_t iBin=1; iBin<=GetNBins(iVar1); iBin++) {
+ TString binLabel = GetAxis(iVar1)->GetBinLabel(iBin) ;
+ if (binLabel.CompareTo("") != 0) projection->GetXaxis()->SetBinLabel(iBin,binLabel);
+ }
+ for (Int_t iBin=1; iBin<=GetNBins(iVar2); iBin++) {
+ TString binLabel = GetAxis(iVar2)->GetBinLabel(iBin) ;
+ if (binLabel.CompareTo("") != 0) projection->GetYaxis()->SetBinLabel(iBin,binLabel);
+ }
+ }
}
- else projection = clone->Projection(iVar);
- delete clone;
- for (Int_t iBin=1; iBin<=GetNBins(iVar); iBin++) {
- TString binLabel = GetAxis(iVar)->GetBinLabel(iBin) ;
- if (binLabel.CompareTo("") != 0) projection->GetXaxis()->SetBinLabel(iBin,binLabel);
+ else {
+ if (iVar1 >= GetNVar() || iVar1 < 0 ||
+ iVar2 >= GetNVar() || iVar2 < 0 ||
+ iVar3 >= GetNVar() || iVar3 < 0 ) {
+ AliError("Non-existent variable, return NULL");
+ return 0x0;
+ }
+ projection = (TH3D*)clone->Projection(iVar1,iVar2,iVar3);
+ for (Int_t iBin=1; iBin<=GetNBins(iVar1); iBin++) {
+ TString binLabel = GetAxis(iVar1)->GetBinLabel(iBin) ;
+ if (binLabel.CompareTo("") != 0) projection->GetXaxis()->SetBinLabel(iBin,binLabel);
+ }
+ for (Int_t iBin=1; iBin<=GetNBins(iVar2); iBin++) {
+ TString binLabel = GetAxis(iVar2)->GetBinLabel(iBin) ;
+ if (binLabel.CompareTo("") != 0) projection->GetYaxis()->SetBinLabel(iBin,binLabel);
+ }
+ for (Int_t iBin=1; iBin<=GetNBins(iVar3); iBin++) {
+ TString binLabel = GetAxis(iVar3)->GetBinLabel(iBin) ;
+ if (binLabel.CompareTo("") != 0) projection->GetZaxis()->SetBinLabel(iBin,binLabel);
+ }
}
- return projection ;
-}
-
-//____________________________________________________________________
-TH2D* AliCFGridSparse::Slice(Int_t iVar1, Int_t iVar2, const Double_t *varMin, const Double_t *varMax, Bool_t useBins) const
-{
- //
- // return a slice (2D-projection) on variables iVar1 and iVar2 while axis ranges are defined with varMin,varMax
- // arrays varMin and varMax contain the min and max values of each variable.
- // therefore varMin and varMax must have their dimensions equal to GetNVar()
- // If useBins=true, varMin and varMax are taken as bin numbers
- THnSparse* clone = (THnSparse*)fData->Clone();
- for (Int_t iAxis=0; iAxis<GetNVar(); iAxis++) {
- if (useBins) clone->GetAxis(iAxis)->SetRange((Int_t)varMin[iAxis],(Int_t)varMax[iAxis]);
- else clone->GetAxis(iAxis)->SetRangeUser(varMin[iAxis],varMax[iAxis]);
- }
-
- TH2D* projection = 0x0 ;
+ projection->SetName (name .Data());
+ projection->SetTitle(title.Data());
- TObject* objInMem = gROOT->FindObject(Form("%s_proj_%d_%d",clone->GetName(),iVar2,iVar1)) ;
- if (objInMem) {
- TString name(objInMem->ClassName());
- if (name.CompareTo("TH2D")==0) projection = (TH2D*) objInMem ;
- else projection = clone->Projection(iVar1,iVar2);
- }
- else projection = clone->Projection(iVar1,iVar2);
delete clone;
- for (Int_t iBin=1; iBin<=GetNBins(iVar1); iBin++) {
- TString binLabel = GetAxis(iVar1)->GetBinLabel(iBin) ;
- if (binLabel.CompareTo("") != 0) projection->GetXaxis()->SetBinLabel(iBin,binLabel);
- }
- for (Int_t iBin=1; iBin<=GetNBins(iVar2); iBin++) {
- TString binLabel = GetAxis(iVar2)->GetBinLabel(iBin) ;
- if (binLabel.CompareTo("") != 0) projection->GetYaxis()->SetBinLabel(iBin,binLabel);
- }
return projection ;
}
//____________________________________________________________________
-TH3D* AliCFGridSparse::Slice(Int_t iVar1, Int_t iVar2, Int_t iVar3, const Double_t *varMin, const Double_t *varMax, Bool_t useBins) const
-{
+void AliCFGridSparse::SetAxisRange(TAxis* axis, Double_t min, Double_t max, Bool_t useBins) const {
//
- // return a slice (3D-projection) on variables iVar1, iVar2 and iVar3 while axis ranges are defined with varMin,varMax
- // arrays varMin and varMax contain the min and max values of each variable.
- // therefore varMin and varMax must have their dimensions equal to GetNVar()
- // If useBins=true, varMin and varMax are taken as bin numbers
-
- THnSparse* clone = (THnSparse*)fData->Clone();
- for (Int_t iAxis=0; iAxis<GetNVar(); iAxis++) {
- if (useBins) clone->GetAxis(iAxis)->SetRange((Int_t)varMin[iAxis],(Int_t)varMax[iAxis]);
- else clone->GetAxis(iAxis)->SetRangeUser(varMin[iAxis],varMax[iAxis]);
- }
-
- TH3D* projection = 0x0 ;
-
- TObject* objInMem = gROOT->FindObject(Form("%s_proj_%d_%d_%d",clone->GetName(),iVar1,iVar2,iVar3)) ;
- if (objInMem) {
- TString name(objInMem->ClassName());
- if (name.CompareTo("TH3D")==0) projection = (TH3D*) objInMem ;
- else projection = clone->Projection(iVar1,iVar2,iVar3);
- }
- else projection = clone->Projection(iVar1,iVar2,iVar3);
- delete clone;
- for (Int_t iBin=1; iBin<=GetNBins(iVar1); iBin++) {
- TString binLabel = GetAxis(iVar1)->GetBinLabel(iBin) ;
- if (binLabel.CompareTo("") != 0) projection->GetXaxis()->SetBinLabel(iBin,binLabel);
- }
- for (Int_t iBin=1; iBin<=GetNBins(iVar2); iBin++) {
- TString binLabel = GetAxis(iVar2)->GetBinLabel(iBin) ;
- if (binLabel.CompareTo("") != 0) projection->GetYaxis()->SetBinLabel(iBin,binLabel);
- }
- for (Int_t iBin=1; iBin<=GetNBins(iVar3); iBin++) {
- TString binLabel = GetAxis(iVar3)->GetBinLabel(iBin) ;
- if (binLabel.CompareTo("") != 0) projection->GetZaxis()->SetBinLabel(iBin,binLabel);
- }
- return projection ;
+ // sets axis range, and forces bit TAxis::kAxisRange
+ //
+
+ if (useBins) axis->SetRange ((Int_t)min,(Int_t)max);
+ else axis->SetRangeUser( min, max);
+ //axis->SetBit(TAxis::kAxisRange); // uncomment when ROOT TAxis is fixed
}
//____________________________________________________________________
-void AliCFGridSparse::SetRangeUser(Int_t iVar, Double_t varMin, Double_t varMax) {
+void AliCFGridSparse::SetRangeUser(Int_t iVar, Double_t varMin, Double_t varMax, Bool_t useBins) const {
//
// set range of axis iVar.
//
- fData->GetAxis(iVar)->SetRangeUser(varMin,varMax);
- AliWarning(Form("THnSparse axis %d range has been modified",iVar));
+ SetAxisRange(fData->GetAxis(iVar),varMin,varMax,useBins);
+ AliInfo(Form("AliCFGridSparse axis %d range has been modified",iVar));
}
//____________________________________________________________________
-void AliCFGridSparse::SetRangeUser(const Double_t *varMin, const Double_t *varMax) {
+void AliCFGridSparse::SetRangeUser(const Double_t *varMin, const Double_t *varMax, Bool_t useBins) const {
//
// set range of every axis. varMin and varMax must be of dimension GetNVar()
//
for (Int_t iAxis=0; iAxis<GetNVar() ; iAxis++) { // set new range for every axis
- SetRangeUser(iAxis,varMin[iAxis],varMax[iAxis]);
+ SetRangeUser(iAxis,varMin[iAxis],varMax[iAxis], useBins);
}
- AliWarning("THnSparse axes ranges have been modified");
-}
-
-//____________________________________________________________________
-void AliCFGridSparse::UseAxisRange(Bool_t b) const {
- for (Int_t iAxis=0; iAxis<GetNVar(); iAxis++) fData->GetAxis(iAxis)->SetBit(TAxis::kAxisRange,b);
+ AliInfo("AliCFGridSparse axes ranges have been modified");
}
//____________________________________________________________________
virtual void SetElementError(const Int_t *bin, Float_t val) ;
virtual void SetElementError(const Double_t *var, Float_t val);
- virtual TH1D* Project( Int_t ivar) const;
- virtual TH2D* Project( Int_t ivar1, Int_t ivar2) const;
- virtual TH3D* Project( Int_t ivar1, Int_t ivar2,Int_t ivar3) const;
- virtual AliCFGridSparse* Project(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Bool_t useBins=0) const ;
- virtual TH1D* Slice(Int_t ivar, const Double_t* varMin, const Double_t* varMax, Bool_t useBins=0) const ;
- virtual TH2D* Slice(Int_t ivar1, Int_t ivar2, const Double_t *varMin, const Double_t *varMax, Bool_t useBins=0) const ;
- virtual TH3D* Slice(Int_t ivar1, Int_t ivar2, Int_t ivar3, const Double_t *varMin, const Double_t *varMax, Bool_t useBins=0) const ;
- virtual void SetRangeUser(Int_t iVar, Double_t varMin, Double_t varMax) ;
- virtual void SetRangeUser(const Double_t* varMin, const Double_t* varMax) ;
- virtual void UseAxisRange(Bool_t b) const ;
+ virtual TH1* Project(Int_t ivar1, Int_t ivar2=-1, Int_t ivar3=-1) const {return Slice(ivar1,ivar2,ivar3,0x0,0x0,kFALSE);}
+ virtual TH1* Slice(Int_t ivar1, Int_t ivar2=-1, Int_t ivar3=-1,
+ const Double_t *varMin=0x0, const Double_t *varMax=0x0, Bool_t useBins=0) const ;
+ virtual AliCFGridSparse* MakeSlice(Int_t nVars, const Int_t* vars,
+ const Double_t* varMin, const Double_t* varMax, Bool_t useBins=0) const ;
+
+ virtual void SetRangeUser(Int_t iVar, Double_t varMin, Double_t varMax, Bool_t useBins=kFALSE) const ;
+ virtual void SetRangeUser(const Double_t* varMin, const Double_t* varMax, Bool_t useBins=kFALSE) const ;
virtual void Smooth() ;
//basic operations
virtual Float_t GetUnderFlows(Int_t var, Bool_t excl=kFALSE) const;
virtual Long_t GetEmptyBins() const;
- // to be implemented
- //------------------
- //virtual Int_t GetEmptyBins(Double_t *varMin,Double_t *varMax) const;
- //virtual Double_t GetIntegral(Int_t *binMin,Int_t *binMax) const;
+ /* FUNCTIONS TO REMOVE */
+ virtual AliCFGridSparse* Project(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Bool_t useBins=0) const
+ {return MakeSlice(nVars,vars,varMin,varMax,useBins);}
+
protected:
//protected functions
- //Float_t GetSum(Int_t ivar, const Int_t *binMin, const Int_t* binMax) const;
void GetScaledValues(const Double_t *fact, const Double_t *in, Double_t *out) const;
+ void SetAxisRange(TAxis* axis, Double_t min, Double_t max, Bool_t useBins) const;
+ void GetProjectionName (TString& s,Int_t var0, Int_t var1=-1, Int_t var2=-1) const;
+ void GetProjectionTitle(TString& s,Int_t var0, Int_t var1=-1, Int_t var2=-1) const;
// data members:
Bool_t fSumW2 ; // Flag to check if calculation of squared weights enabled
return -1;
}
+inline void AliCFGridSparse::GetProjectionName (TString& s, Int_t var0, Int_t var1, Int_t var2) const {
+ s.Form("%s_proj-%s",GetName(),GetVarTitle(var0));
+ if (var1>=0) {
+ s.Append(Form("-%s",GetVarTitle(var1)));
+ if (var2>=0) s.Append(Form("-%s",GetVarTitle(var2)));
+ }
+}
+
+inline void AliCFGridSparse::GetProjectionTitle(TString& s, Int_t var0, Int_t var1, Int_t var2) const {
+ s.Form("%s: projection on %s",GetTitle(),GetVarTitle(var0));
+ if (var1>=0) {
+ s.Append(Form("-%s",GetVarTitle(var1)));
+ if (var2>=0) s.Append(Form("-%s",GetVarTitle(var2)));
+ }
+}
+
#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff