// in bins of cut variables //
// Origin: Elena Bruna (bruna@to.infn.it) //
// Updated: Sergey Senyukov (senyukov@to.infn.it) //
-// Last updated: Francesco Prino (prino@to.infn.it) //
+// Francesco Prino (prino@to.infn.it) //
+// Last Updated: Giacomo Ortona (ortona@to.infn.it) //
// //
///////////////////////////////////////////////////////////////////
#include "TArrayI.h"
#include "TNamed.h"
#include "TH2.h"
+#include "TMath.h"
#include "TString.h"
class AliMultiDimVector : public TNamed{
public:
AliMultiDimVector();
AliMultiDimVector(const AliMultiDimVector &mv);
- AliMultiDimVector(const char *name, const char *title, const Int_t npars, Int_t nptbins, Int_t *nofcells, Float_t *loosecuts, Float_t *tightcuts, TString *axisTitles);
+ AliMultiDimVector(const char *name, const char *title, const Int_t nptbins,
+ const Float_t* ptlimits, const Int_t npars, const Int_t *nofcells, const Float_t *loosecuts, const Float_t *tightcuts, const TString *axisTitles);
virtual ~AliMultiDimVector(){};
ULong64_t GetNTotCells() const {return fNTotCells;}
else return fMaxLimits[iVar]-(Float_t)iCell*GetCutStep(iVar);
}
Float_t GetElement(ULong64_t globadd) const {return fVett[globadd];}
- Float_t GetElement(Int_t *ind, Int_t ptbin) const {
+ Float_t GetElement(const Int_t *ind, Int_t ptbin) const {
ULong64_t elem=GetGlobalAddressFromIndices(ind,ptbin);
return fVett[elem];
}
+ Float_t GetPtLimit(Int_t i) const{return fPtLimits[i];}
+ Int_t GetPtBin(const Float_t pt) const{
+ Int_t theBin=TMath::BinarySearch(fNPtBins+1,fPtLimits,pt);
+ if(theBin>=fNPtBins) theBin=-1;
+ return theBin;
+ }
void GetEntireMultiDimVector(Float_t *vett) const {
for(ULong64_t i=0; i<fNTotCells; i++) vett[i]=fVett[i];
}
Bool_t GetIndicesFromGlobalAddress(ULong64_t globadd, Int_t *ind, Int_t &ptbin) const;
- ULong64_t GetGlobalAddressFromIndices(Int_t *ind, Int_t ptbin) const;
- Bool_t GetIndicesFromValues(Float_t *values, Int_t *ind) const;
- ULong64_t GetGlobalAddressFromValues(Float_t *values, Int_t ptbin) const;
+ ULong64_t GetGlobalAddressFromIndices(const Int_t *ind, Int_t ptbin) const;
+ Bool_t GetIndicesFromValues(const Float_t *values, Int_t *ind) const;
+ ULong64_t GetGlobalAddressFromValues(const Float_t *values, Int_t ptbin) const;
Bool_t GetCutValuesFromGlobalAddress(ULong64_t globadd, Float_t *cuts, Int_t &ptbin) const;
+
+ ULong64_t* GetGlobalAddressesAboveCuts(const Float_t *values, Float_t pt, Int_t& nVals) const{
+ Int_t theBin=GetPtBin(pt);
+ if(theBin>=0) return GetGlobalAddressesAboveCuts(values,theBin,nVals);
+ else return 0x0;
+ }
+ ULong64_t* GetGlobalAddressesAboveCuts(const Float_t *values, Int_t ptbin, Int_t& nVals) const;
+ Bool_t GetGreaterThan(Int_t iVar) const {return fGreaterThan[iVar];}
void SetElement(ULong64_t globadd,Float_t val) {fVett[globadd]=val;}
void SetElement(Int_t *ind, Int_t ptbin, Float_t val){
ULong64_t elem=GetGlobalAddressFromIndices(ind,ptbin);
+ if(elem>fNTotCells){
+ printf("SetElement: indices %d %d %d ptbin %d elem %d\n",ind[0],ind[1],ind[2],ptbin,(Int_t)elem);
+ }
fVett[elem]=val;
}
void IncrementElement(Int_t *ind, Int_t ptbin){
for(ULong64_t i=0; i<fNTotCells; i++) fVett[i]=0.;
}
void MultiplyBy(Float_t factor);
- void Multiply(AliMultiDimVector* mv,Float_t factor);
- void Multiply(AliMultiDimVector* mv1, AliMultiDimVector* mv2);
- void Add(AliMultiDimVector* mv);
- void Sum(AliMultiDimVector* mv1, AliMultiDimVector* mv2);
- void LinearComb(AliMultiDimVector* mv1, Float_t norm1, AliMultiDimVector* mv2, Float_t norm2);
- void DivideBy(AliMultiDimVector* mv);
- void Divide(AliMultiDimVector* mv1, AliMultiDimVector* mv2);
+ void Multiply(const AliMultiDimVector* mv,Float_t factor);
+ void Multiply(const AliMultiDimVector* mv1, const AliMultiDimVector* mv2);
+ void Add(const AliMultiDimVector* mv);
+ void Sum(const AliMultiDimVector* mv1, const AliMultiDimVector* mv2);
+ void LinearComb(const AliMultiDimVector* mv1, Float_t norm1, const AliMultiDimVector* mv2, Float_t norm2);
+ void DivideBy(const AliMultiDimVector* mv);
+ void Divide(const AliMultiDimVector* mv1, const AliMultiDimVector* mv2);
void Sqrt();
- void Sqrt(AliMultiDimVector* mv);
+ void Sqrt(const AliMultiDimVector* mv);
void FindMaximum(Float_t& max_value, Int_t *ind, Int_t ptbin);
- TH2F* Project(Int_t firstVar, Int_t secondVar, Int_t* fixedVars, Int_t ptbin, Float_t norm=1.);
+ TH2F* Project(Int_t firstVar, Int_t secondVar, const Int_t* fixedVars, Int_t ptbin, Float_t norm=1.);
- void SuppressZeroBKGEffect(AliMultiDimVector* BKG);
- AliMultiDimVector* ShrinkPtBins(Int_t firstBin, Int_t lastBin);
+ void SuppressZeroBKGEffect(const AliMultiDimVector* BKG);
+ AliMultiDimVector* ShrinkPtBins(Int_t firstBin, Int_t lastBin);
+
+ void SetNewLimits(Float_t* loose,Float_t* tight);
+ void SwapLimits(Int_t ilim);
+
+
+ void PrintStatus();
protected:
void GetIntegrationLimits(Int_t iVar, Int_t iCell, Int_t& minbin, Int_t& maxbin) const;
void GetFillRange(Int_t iVar, Int_t iCell, Int_t& minbin, Int_t& maxbin) const;
- Bool_t GetGreaterThan(Int_t iVar) const {return fGreaterThan[iVar];}
Float_t CountsAboveCell(ULong64_t globadd) const;
+ //void SetMinLimits(Int_t nvar, Float_t* minlim);
+ //void SetMaxLimits(Int_t nvar, Float_t* maxlim);
private:
static const Int_t fgkMaxNVariables=10; // max. n. of selection variables
+ static const Int_t fgkMaxNPtBins=10; // max. n. of Pt bins
Int_t fNVariables; // n. of selection variables
Int_t fNPtBins; // n. of pt bins
+ Float_t fPtLimits[fgkMaxNPtBins+1]; // limits of pt bins
Int_t fNCutSteps[fgkMaxNVariables]; // n. of cut step for each variable
Float_t fMinLimits[fgkMaxNVariables]; // lower cut value for each variable
Float_t fMaxLimits[fgkMaxNVariables]; // higher cut value for each variable
ULong64_t fNTotCells; // total number of matrix elements
Bool_t fIsIntegrated; // flag for integrated matrix
- ClassDef(AliMultiDimVector,1); // a multi-dimensional vector class
+ ClassDef(AliMultiDimVector,2); // a multi-dimensional vector class
};
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff