ROOT logo
#ifndef ALIMULTIDIMVECTOR_H
#define ALIMULTIDIMVECTOR_H

/* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */

///////////////////////////////////////////////////////////////////
//                                                               //
// Class to store number of signal and background candidates     //
// in bins of cut variables                                      //
// Origin:       Elena Bruna (bruna@to.infn.it)                  //
// Updated:      Sergey Senyukov (senyukov@to.infn.it)           //
//               Francesco Prino (prino@to.infn.it)              //
// Last Updated: Giacomo Ortona (ortona@to.infn.it)              //
//                                                               //
///////////////////////////////////////////////////////////////////

#include "TArrayF.h"
#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& operator=(const AliMultiDimVector &mv); 
  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;}
  Int_t     GetNVariables()           const {return fNVariables;}
  Int_t     GetNPtBins()              const {return fNPtBins;}
  Int_t     GetNCutSteps(Int_t iVar)  const {return fNCutSteps[iVar];}
  Float_t   GetMinLimit(Int_t iVar)   const {return fMinLimits[iVar];}
  Float_t   GetMaxLimit(Int_t iVar)   const {return fMaxLimits[iVar];}
  Float_t   GetCutStep(Int_t iVar)    const {return (fMaxLimits[iVar]-fMinLimits[iVar])/(Float_t)fNCutSteps[iVar];}
  TString   GetAxisTitle(Int_t iVar)  const {return fAxisTitles[iVar];}
  Bool_t    IsIntegrated()            const {return fIsIntegrated;}

  void CopyStructure(const AliMultiDimVector* mv);

  Float_t   GetCutValue(Int_t iVar, Int_t iCell) const{
    if(fGreaterThan[iVar]) return fMinLimits[iVar]+(Float_t)iCell*GetCutStep(iVar);
    else return fMaxLimits[iVar]-(Float_t)iCell*GetCutStep(iVar);
  }
  Float_t   GetElement(ULong64_t globadd) const {return fVett[globadd];}
  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(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){
    SetElement(ind,ptbin,GetElement(ind,ptbin)+1);
  }
  void IncrementElement(ULong64_t globadd){
    SetElement(globadd,GetElement(globadd)+1.);
  }

  void Fill(Float_t* values, Int_t ptbin);
  void FillAndIntegrate(Float_t* values, Int_t ptbin);
  void Integrate();

  void Reset(){
    for(ULong64_t i=0; i<fNTotCells; i++) fVett[i]=0.;
  }
  void MultiplyBy(Float_t factor);
  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(const AliMultiDimVector* mv);
  
  void FindMaximum(Float_t& max_value, Int_t *ind, Int_t ptbin); 
  Int_t* FindLocalMaximum(Float_t& maxValue, Int_t *numFixed,Int_t* indFixed, Int_t nfixed,Int_t ptbin);

  TH2F*  Project(Int_t firstVar, Int_t secondVar, const Int_t* fixedVars, Int_t ptbin, Float_t norm=1.);

  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;
  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
  Bool_t    fGreaterThan[fgkMaxNVariables];// sign of the cut (> or <)
  TString   fAxisTitles[fgkMaxNVariables]; // titles for variables
  TArrayF   fVett;                   // array with n. of candidates vs. cuts
  ULong64_t fNTotCells;              // total number of matrix elements
  Bool_t    fIsIntegrated;           // flag for integrated matrix 

  ClassDef(AliMultiDimVector,2); // a multi-dimensional vector class

};

#endif
 AliMultiDimVector.h:1
 AliMultiDimVector.h:2
 AliMultiDimVector.h:3
 AliMultiDimVector.h:4
 AliMultiDimVector.h:5
 AliMultiDimVector.h:6
 AliMultiDimVector.h:7
 AliMultiDimVector.h:8
 AliMultiDimVector.h:9
 AliMultiDimVector.h:10
 AliMultiDimVector.h:11
 AliMultiDimVector.h:12
 AliMultiDimVector.h:13
 AliMultiDimVector.h:14
 AliMultiDimVector.h:15
 AliMultiDimVector.h:16
 AliMultiDimVector.h:17
 AliMultiDimVector.h:18
 AliMultiDimVector.h:19
 AliMultiDimVector.h:20
 AliMultiDimVector.h:21
 AliMultiDimVector.h:22
 AliMultiDimVector.h:23
 AliMultiDimVector.h:24
 AliMultiDimVector.h:25
 AliMultiDimVector.h:26
 AliMultiDimVector.h:27
 AliMultiDimVector.h:28
 AliMultiDimVector.h:29
 AliMultiDimVector.h:30
 AliMultiDimVector.h:31
 AliMultiDimVector.h:32
 AliMultiDimVector.h:33
 AliMultiDimVector.h:34
 AliMultiDimVector.h:35
 AliMultiDimVector.h:36
 AliMultiDimVector.h:37
 AliMultiDimVector.h:38
 AliMultiDimVector.h:39
 AliMultiDimVector.h:40
 AliMultiDimVector.h:41
 AliMultiDimVector.h:42
 AliMultiDimVector.h:43
 AliMultiDimVector.h:44
 AliMultiDimVector.h:45
 AliMultiDimVector.h:46
 AliMultiDimVector.h:47
 AliMultiDimVector.h:48
 AliMultiDimVector.h:49
 AliMultiDimVector.h:50
 AliMultiDimVector.h:51
 AliMultiDimVector.h:52
 AliMultiDimVector.h:53
 AliMultiDimVector.h:54
 AliMultiDimVector.h:55
 AliMultiDimVector.h:56
 AliMultiDimVector.h:57
 AliMultiDimVector.h:58
 AliMultiDimVector.h:59
 AliMultiDimVector.h:60
 AliMultiDimVector.h:61
 AliMultiDimVector.h:62
 AliMultiDimVector.h:63
 AliMultiDimVector.h:64
 AliMultiDimVector.h:65
 AliMultiDimVector.h:66
 AliMultiDimVector.h:67
 AliMultiDimVector.h:68
 AliMultiDimVector.h:69
 AliMultiDimVector.h:70
 AliMultiDimVector.h:71
 AliMultiDimVector.h:72
 AliMultiDimVector.h:73
 AliMultiDimVector.h:74
 AliMultiDimVector.h:75
 AliMultiDimVector.h:76
 AliMultiDimVector.h:77
 AliMultiDimVector.h:78
 AliMultiDimVector.h:79
 AliMultiDimVector.h:80
 AliMultiDimVector.h:81
 AliMultiDimVector.h:82
 AliMultiDimVector.h:83
 AliMultiDimVector.h:84
 AliMultiDimVector.h:85
 AliMultiDimVector.h:86
 AliMultiDimVector.h:87
 AliMultiDimVector.h:88
 AliMultiDimVector.h:89
 AliMultiDimVector.h:90
 AliMultiDimVector.h:91
 AliMultiDimVector.h:92
 AliMultiDimVector.h:93
 AliMultiDimVector.h:94
 AliMultiDimVector.h:95
 AliMultiDimVector.h:96
 AliMultiDimVector.h:97
 AliMultiDimVector.h:98
 AliMultiDimVector.h:99
 AliMultiDimVector.h:100
 AliMultiDimVector.h:101
 AliMultiDimVector.h:102
 AliMultiDimVector.h:103
 AliMultiDimVector.h:104
 AliMultiDimVector.h:105
 AliMultiDimVector.h:106
 AliMultiDimVector.h:107
 AliMultiDimVector.h:108
 AliMultiDimVector.h:109
 AliMultiDimVector.h:110
 AliMultiDimVector.h:111
 AliMultiDimVector.h:112
 AliMultiDimVector.h:113
 AliMultiDimVector.h:114
 AliMultiDimVector.h:115
 AliMultiDimVector.h:116
 AliMultiDimVector.h:117
 AliMultiDimVector.h:118
 AliMultiDimVector.h:119
 AliMultiDimVector.h:120
 AliMultiDimVector.h:121
 AliMultiDimVector.h:122
 AliMultiDimVector.h:123
 AliMultiDimVector.h:124
 AliMultiDimVector.h:125
 AliMultiDimVector.h:126
 AliMultiDimVector.h:127
 AliMultiDimVector.h:128
 AliMultiDimVector.h:129
 AliMultiDimVector.h:130
 AliMultiDimVector.h:131
 AliMultiDimVector.h:132
 AliMultiDimVector.h:133
 AliMultiDimVector.h:134
 AliMultiDimVector.h:135
 AliMultiDimVector.h:136
 AliMultiDimVector.h:137
 AliMultiDimVector.h:138
 AliMultiDimVector.h:139
 AliMultiDimVector.h:140
 AliMultiDimVector.h:141
 AliMultiDimVector.h:142
 AliMultiDimVector.h:143
 AliMultiDimVector.h:144
 AliMultiDimVector.h:145
 AliMultiDimVector.h:146
 AliMultiDimVector.h:147
 AliMultiDimVector.h:148
 AliMultiDimVector.h:149
 AliMultiDimVector.h:150
 AliMultiDimVector.h:151
 AliMultiDimVector.h:152
 AliMultiDimVector.h:153
 AliMultiDimVector.h:154
 AliMultiDimVector.h:155
 AliMultiDimVector.h:156