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