STEER/ESD/AliESDCaloCells.h

   1 #ifndef ALIESDCALOCELLS_H
   2 #define ALIESDCALOCELLS_H
   3 /* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice                               */
   5 /* $Id$ */
   6 /* $Log $ */
   7
   8 //-------------------------------------------------------------------------
   9 //     ESD class to store calorimeter cell data
  10 //     Clone of AliAODCaloCells made by Markus Oldenburg, CERN
  11 //     Author: Gustavo Conesa Balbastre INFN-LNF
  12 //
  13 //-------------------------------------------------------------------------
  14
  15
  16 #include <AliVCaloCells.h>
  17 #include <TMath.h>
  18
  19 class AliESDCaloCells : public AliVCaloCells
  20 {
  21  public:
  22
  23   AliESDCaloCells();
  24   AliESDCaloCells(const char* name, const char* title, VCells_t ttype=kUndef);
  25   AliESDCaloCells(const AliESDCaloCells & cells);
  26   AliESDCaloCells & operator=(const AliESDCaloCells& source);
  27   virtual ~AliESDCaloCells();
  28
  29   virtual AliVCaloCells * CopyCaloCells(Bool_t all) const;
  30   virtual void    Copy(TObject &obj) const;
  31   void            Clear(const Option_t*);
  32   void            CreateContainer(Short_t nCells);
  33   void            DeleteContainer();
  34   void            Sort();
  35
  36   Bool_t          IsEMCAL()  const { return (fType == kEMCALCell); }
  37   Bool_t          IsPHOS()   const { return (fType == kPHOSCell) ; }
  38   Char_t          GetType()  const { return  fType               ; }
  39   void            SetType(Char_t t){ fType = t                   ; }
  40
  41   inline Bool_t   GetCell(Short_t pos, Short_t &cellNumber, Double_t &amplitude, Double_t &time, Int_t &mclabel,      Double_t &efrac) const;
  42   Bool_t          SetCell(Short_t pos, Short_t  cellNumber, Double_t  amplitude, Double_t  time, Int_t  mclabel = -1, Double_t  efrac = 0., Bool_t isHG=kFALSE);
  43
  44   Short_t         GetNumberOfCells() const  { return fNCells ; }
  45   void            SetNumberOfCells(Int_t n) { fNCells = n    ; }
  46
  47
  48   inline Double_t GetCellAmplitude(Short_t cellNumber);
  49   inline Bool_t   GetCellHighGain(Short_t cellNumber);  //is this cell High Gain
  50   inline Short_t  GetCellPosition(Short_t cellNumber);
  51   inline Double_t GetCellTime(Short_t cellNumber);
  52
  53   inline Double_t GetAmplitude(Short_t pos) const;
  54   inline Bool_t   GetHighGain(Short_t pos) const;
  55   inline Double_t GetTime(Short_t pos) const;
  56   inline Short_t  GetCellNumber(Short_t pos) const;
  57
  58   // MC & embedding
  59   inline Int_t    GetCellMCLabel(Short_t cellNumber) ;
  60   inline Int_t    GetMCLabel(Short_t pos) const ;
  61
  62   inline Double_t GetCellEFraction(Short_t cellNumber) ;
  63   inline Double_t GetEFraction(Short_t pos) const ;
  64
  65   inline void     SetEFraction    (Short_t pos,         Double32_t efrac) ;
  66   inline void     SetCellEFraction(Short_t cellNumber,  Double32_t efrac) ;
  67
  68  protected:
  69
  70   Int_t       fNCells;       // Number of cells
  71   Bool_t     *fHGLG;         //[fNCells] if sell HG or LG
  72   Short_t    *fCellNumber;   //[fNCells] array of cell numbers
  73   Double32_t *fAmplitude;    //[fNCells][0.,0.,16] array with cell amplitudes (= energy!)
  74   Double32_t *fTime;         //[fNCells][0.,0.,16] array with cell times
  75   Double32_t *fEFraction;    //[fNCells][0.,0.,16] array with fraction of MC energy and data - for embedding
  76   Int_t      *fMCLabel;      //[fNCells] array of MC labels
  77   Bool_t      fIsSorted;     //! true if cell arrays are sorted by index
  78   Char_t      fType;         // Cell type
  79
  80   ClassDef(AliESDCaloCells, 5);
  81 };
  82
  83
  84 Bool_t AliESDCaloCells::GetCell(Short_t pos, Short_t &cellNumber, Double_t &amplitude,
  85                                 Double_t & time, Int_t & mclabel, Double_t & efrac) const
  86 {
  87   if (pos>=0 && pos<fNCells)
  88   {
  89     cellNumber = fCellNumber[pos];
  90     amplitude  = fAmplitude[pos];
  91     time       = fTime[pos];
  92
  93     if(fMCLabel)   mclabel = fMCLabel[pos];
  94     else           mclabel =-1 ;
  95     if(fEFraction) efrac   = fEFraction[pos];
  96     else           efrac   = 0 ;
  97
  98     return kTRUE;
  99
 100   } else
 101   {
 102     return kFALSE;
 103   }
 104 }
 105
 106 Double_t AliESDCaloCells::GetCellAmplitude(Short_t cellNumber)
 107 {
 108   if (!fIsSorted) {
 109     Sort();
 110     fIsSorted=kTRUE;
 111   }
 112
 113   Short_t pos = TMath::BinarySearch(fNCells, fCellNumber, cellNumber);
 114   if (pos>=0 && pos < fNCells && fCellNumber[pos] == cellNumber ) {
 115     return fAmplitude[pos];
 116   } else {
 117     return 0.;
 118   }
 119 }
 120
 121 Bool_t AliESDCaloCells::GetCellHighGain(Short_t cellNumber)
 122 {
 123   if (!fIsSorted) {
 124     Sort();
 125     fIsSorted=kTRUE;
 126   }
 127
 128   Short_t pos = TMath::BinarySearch(fNCells, fCellNumber, cellNumber);
 129   if (pos>=0 && pos < fNCells && fCellNumber[pos] == cellNumber ) {
 130     if(fHGLG)
 131       return fHGLG[pos];
 132     else{
 133       if(fMCLabel)//old version of ESD, for data HG flag stored in MCLabel
 134         return !(fMCLabel[pos]==-2) ;
 135       else
 136         return kTRUE ;
 137     }
 138   } else {
 139     return kFALSE;
 140   }
 141 }
 142
 143 Double_t AliESDCaloCells::GetCellTime(Short_t cellNumber)
 144 {
 145   if (!fIsSorted) {
 146     Sort();
 147     fIsSorted=kTRUE;
 148   }
 149
 150   Short_t pos = TMath::BinarySearch(fNCells, fCellNumber, cellNumber);
 151   if (pos>=0 && pos < fNCells && fCellNumber[pos] == cellNumber) {
 152     return fTime[pos];
 153   } else {
 154     return -1.;
 155   }
 156 }
 157
 158 Double_t AliESDCaloCells::GetAmplitude(Short_t pos) const
 159 {
 160   if (pos>=0 && pos<fNCells) {
 161     return fAmplitude[pos];
 162   } else {
 163     return 0.;
 164   }
 165 }
 166 Bool_t AliESDCaloCells::GetHighGain(Short_t pos) const
 167 {
 168   if (pos>=0 && pos<fNCells) {
 169     if(fHGLG)
 170       return fHGLG[pos];
 171     else{
 172       if(fMCLabel)//old version of ESD, for data HG flag stored in MCLabel
 173         return !(fMCLabel[pos]==-2) ;
 174       else
 175         return kTRUE ;
 176     }
 177   } else {
 178     return kFALSE;
 179   }
 180 }
 181
 182 Double_t AliESDCaloCells::GetTime(Short_t pos) const
 183 {
 184   if (pos>=0 && pos<fNCells) {
 185     return fTime[pos];
 186   } else {
 187     return -1.;
 188   }
 189 }
 190
 191 Short_t AliESDCaloCells::GetCellNumber(Short_t pos) const
 192 {
 193   if (pos>=0 && pos<fNCells) {
 194     return fCellNumber[pos];
 195   } else {
 196     return fNCells;
 197   }
 198 }
 199
 200 Short_t AliESDCaloCells::GetCellPosition(Short_t cellNumber)
 201 {
 202   if (!fIsSorted) {
 203     Sort();
 204     fIsSorted=kTRUE;
 205   }
 206
 207   Int_t nabove, nbelow, middle;
 208   Short_t pos = -1;
 209
 210   nabove = fNCells + 1;
 211   nbelow = 0;
 212   while (nabove - nbelow > 1) {
 213     middle = (nabove + nbelow) / 2;
 214     if (cellNumber == fCellNumber[middle-1]) {
 215       pos =   middle - 1;
 216       break;
 217     }
 218     if (cellNumber  < fCellNumber[middle-1]) nabove = middle;
 219     else                                     nbelow = middle;
 220   }
 221
 222   return pos;
 223 }
 224
 225 Int_t AliESDCaloCells::GetMCLabel(Short_t pos) const
 226 {
 227   if (pos>=0 && pos<fNCells && fMCLabel) {
 228     return fMCLabel[pos];
 229   } else {
 230     return -1 ;
 231   }
 232 }
 233
 234 Double_t AliESDCaloCells::GetEFraction(Short_t pos) const
 235 {
 236   if (pos>=0 && pos<fNCells && fEFraction) {
 237     return fEFraction[pos];
 238   } else {
 239     return 0.;
 240   }
 241 }
 242
 243 Int_t AliESDCaloCells::GetCellMCLabel(Short_t cellNumber)
 244 {
 245   if (!fIsSorted) {
 246     Sort();
 247     fIsSorted=kTRUE;
 248   }
 249
 250   Short_t pos = TMath::BinarySearch(fNCells, fCellNumber, cellNumber);
 251   if (pos>=0 && fCellNumber[pos] == cellNumber && fMCLabel) {
 252     return fMCLabel[pos];
 253   } else {
 254     return -1;
 255   }
 256 }
 257
 258 Double_t AliESDCaloCells::GetCellEFraction(Short_t cellNumber)
 259 {
 260   if (!fIsSorted) {
 261     Sort();
 262     fIsSorted=kTRUE;
 263   }
 264
 265   Short_t pos = TMath::BinarySearch(fNCells, fCellNumber, cellNumber);
 266   if (pos>=0 && pos < fNCells && fCellNumber[pos] == cellNumber && fEFraction) {
 267     return fEFraction[pos];
 268   } else {
 269     return 0.;
 270   }
 271 }
 272
 273 void AliESDCaloCells::SetEFraction(Short_t pos,  Double32_t efrac)
 274 {
 275   // Sets the fraction of energy from MC with respect to data at the given position
 276
 277   if (pos>=0 && pos < fNCells)
 278   {
 279     if(!fEFraction) fEFraction = new Double32_t[fNCells];
 280     fEFraction[pos]  = efrac;
 281   }
 282 }
 283
 284 void AliESDCaloCells::SetCellEFraction(Short_t cellNumber, Double32_t efrac)
 285 {
 286   if (!fIsSorted) {
 287     Sort();
 288     fIsSorted=kTRUE;
 289   }
 290
 291   Short_t pos = TMath::BinarySearch(fNCells, fCellNumber, cellNumber);
 292   if (pos>=0 && pos < fNCells && fCellNumber[pos] == cellNumber)
 293   {
 294     if(!fEFraction) fEFraction = new Double32_t[fNCells];
 295     fEFraction[pos] = efrac;
 296   }
 297 }
 298
 299
 300 #endif