ALIROOT-5492 Add field to separate HG and LG digits
[u/mrichter/AliRoot.git] / STEER / AOD / AliAODCaloCells.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 //-------------------------------------------------------------------------
19 //     AOD class to store calorimeter cell data
20 //     Author: Markus Oldenburg, CERN
21 //-------------------------------------------------------------------------
22
23 #include "AliAODCaloCells.h"
24
25 ClassImp(AliAODCaloCells)
26
27 //_______________________________________________________
28 AliAODCaloCells::AliAODCaloCells() : 
29     AliVCaloCells(), fNCells(0), fHGLG(0), fCellNumber(0), 
30     fAmplitude(0), fTime(0), fEFraction(0), fMCLabel(0),
31     fIsSorted(kTRUE), fType(kUndef)
32 {
33   // default constructor
34 }
35
36 //_____________________________________________________________________________________
37 AliAODCaloCells::AliAODCaloCells(const char* name, const char* title, VCells_t ttype) :
38     AliVCaloCells(name, title), fNCells(0), fHGLG(0), fCellNumber(0), 
39     fAmplitude(0), fTime(0), fEFraction(0), fMCLabel(0),
40     fIsSorted(kTRUE), fType(ttype)
41 {
42   //constructor
43 }
44
45 //________________________________________________________________
46 AliAODCaloCells::AliAODCaloCells(const AliAODCaloCells& cells) :
47     AliVCaloCells(cells), fNCells(cells.fNCells), fHGLG(0), fCellNumber(0),
48     fAmplitude(0), fTime(0), fEFraction(0), fMCLabel(0),
49     fIsSorted(cells.fIsSorted), fType(cells.fType)
50 {
51 // Copy constructor
52   fHGLG       = new Bool_t[fNCells] ;
53   fCellNumber = new Short_t[fNCells];
54   fAmplitude  = new Double32_t[fNCells]; 
55   fTime       = new Double32_t[fNCells]; 
56   fMCLabel    = new Int_t[fNCells]; 
57   fEFraction  = new Double32_t[fNCells]; 
58
59   for (Int_t i = 0; i < fNCells; i++) {
60     fHGLG[i]          = cells.fHGLG[i];     
61     fCellNumber[i]    = cells.fCellNumber[i];
62     fAmplitude[i]     = cells.fAmplitude[i];
63     if(cells.fTime)  fTime[i]      = cells.fTime[i];
64     if(cells.fMCLabel)  fMCLabel[i]   = cells.fMCLabel[i];
65     if(cells.fEFraction)fEFraction[i] = cells.fEFraction[i];    
66   }
67 }
68
69 //________________________________________________________________________
70 AliAODCaloCells& AliAODCaloCells::operator=(const AliAODCaloCells& source)
71 {
72   // Assignment operator
73   if(this != &source) 
74   {
75     AliVCaloCells::operator=(source);
76     
77     if(fNCells != source.fNCells) 
78     {
79       delete [] fHGLG ;
80       delete [] fCellNumber;
81       delete [] fAmplitude;
82       delete [] fTime;
83       delete [] fMCLabel;
84       delete [] fEFraction;
85
86       fNCells     = source.fNCells;
87       
88       fHGLG       = new Bool_t[fNCells] ;
89       fCellNumber = new Short_t[fNCells];
90       fAmplitude  = new Double32_t[fNCells];
91       fTime       = new Double32_t[fNCells];
92       fMCLabel    = new Int_t[fNCells];
93       fEFraction  = new Double32_t[fNCells];
94     }
95     
96     memcpy(fCellNumber,source.fHGLG,fNCells*sizeof(Bool_t));
97     memcpy(fCellNumber,source.fCellNumber, fNCells*sizeof(Short_t));
98     memcpy(fAmplitude, source.fAmplitude,  fNCells*sizeof(Double32_t));
99     if(source.fTime      && fTime)      memcpy(fTime,      source.fTime,      fNCells*sizeof(Double32_t));
100     if(source.fMCLabel   && fMCLabel)   memcpy(fMCLabel,   source.fMCLabel,   fNCells*sizeof(Int_t));
101     if(source.fEFraction && fEFraction) memcpy(fEFraction, source.fEFraction, fNCells*sizeof(Double32_t));
102
103     fIsSorted = source.fIsSorted;
104     fType     = source.fType;
105   }
106
107   return *this;
108   
109 }
110
111 //_________________________________
112 AliAODCaloCells::~AliAODCaloCells()
113 {
114   // destructor
115
116   DeleteContainer();
117 }
118
119 void AliAODCaloCells::Clear(const Option_t*)
120 {
121   // clear
122   
123   DeleteContainer();
124 }
125
126 void AliAODCaloCells::Copy(TObject &obj) const 
127 {
128   
129   // this overwrites the virtual TOBject::Copy()
130   // to allow run time copying without casting
131   // in AliESDEvent
132   
133   if(this==&obj)return;
134   AliAODCaloCells *robj = dynamic_cast<AliAODCaloCells*>(&obj);
135   if(!robj)return; // not an AliAODCaloCells
136   *robj = *this;
137   
138 }
139
140 //______________________________________________________________________
141 AliVCaloCells *AliAODCaloCells::CopyCaloCells(Bool_t all = kTRUE) const 
142 {
143   
144   // copy the calo cells into a new object. If option all=FALSE, just the object type, 
145   // for mixing
146   
147   AliVCaloCells *obj =  new AliAODCaloCells();
148   
149   if(all){
150     obj->SetName (GetName()) ; 
151     obj->SetTitle(GetTitle()) ; 
152     obj->SetType (GetType()) ; 
153   
154     obj->SetNumberOfCells(fNCells);
155     for (Short_t i = 0; i < fNCells; i++) 
156     {
157       Int_t mclabel = -1;
158       if(fMCLabel) mclabel = fMCLabel[i];
159       
160       Float_t efrac = 0.;
161       if(fEFraction) efrac = fEFraction[i];
162       
163       Float_t time = -1;
164       if(fTime) time = fTime[i];
165       
166       obj->SetCell(i,fCellNumber[i],fAmplitude[i],time,mclabel,efrac);
167     }
168   }
169   
170   return obj;
171   
172 }
173
174 //___________________________________________________
175 void AliAODCaloCells::CreateContainer(Short_t nCells)
176 {
177   // function that creates container to store calorimeter cell data
178
179   DeleteContainer();
180   
181   if (nCells <= 0) 
182   {
183     fNCells = 0;
184     return;
185   }
186
187   fNCells = nCells;
188
189   fHGLG       = new Bool_t[fNCells];
190   fCellNumber = new Short_t[fNCells];
191   fAmplitude  = new Double32_t[fNCells];
192   fTime       = new Double32_t[fNCells];
193   fMCLabel    = new Int_t[fNCells];
194   fEFraction  = new Double32_t[fNCells];
195
196   // set to zero
197   for(int i = 0;i<fNCells;++i)
198   {
199     fHGLG[i]=kFALSE ;
200     fAmplitude [i] =  0.; 
201     fCellNumber[i] = -1 ; 
202     fEFraction [i] =  0.;
203     fTime      [i] = -1.;
204     fMCLabel   [i] = -1 ;
205   }
206 }
207
208 //_____________________________________
209 void AliAODCaloCells::DeleteContainer()
210 {
211   // deletes allocated memory
212   if(fHGLG){
213     delete[] fHGLG;
214     fHGLG = 0 ;
215   }
216
217   if (fCellNumber)
218   {
219     delete[] fCellNumber;
220     fCellNumber = NULL;
221   }
222
223   if (fAmplitude)
224   {
225     delete[] fAmplitude;
226     fAmplitude = NULL;
227   }
228   
229   if (fTime)
230   {
231     delete[] fTime;
232     fTime = NULL;
233   }
234   
235   if (fMCLabel)
236   {
237     delete[] fMCLabel;
238     fMCLabel = NULL;
239   }
240   
241   if (fEFraction)
242   {
243     delete[] fEFraction;
244     fEFraction = NULL;
245   }
246   
247   
248   fNCells = 0;
249   fIsSorted = kFALSE;
250 }
251
252 //__________________________
253 void AliAODCaloCells::Sort() 
254 {
255   // sort the cell array by cell number
256   
257   Int_t *idxArray = new Int_t[fNCells];
258   TMath::Sort(fNCells,fCellNumber,idxArray,kFALSE);
259   
260   Bool_t     *newHGLG      = new Bool_t[fNCells];
261   Short_t    *newIndex     = new Short_t[fNCells];
262   Double32_t *newAmplitude = new Double32_t[fNCells];
263   
264   Double32_t *newTime      = 0; 
265   Int_t     *newMCLabel   = 0 ;
266   Double32_t *newEFraction = 0 ; 
267   if(fTime)      newTime      = new Double32_t[fNCells];
268   if(fMCLabel)   newMCLabel   = new Int_t[fNCells];
269   if(fEFraction) newEFraction = new Double32_t[fNCells];
270   
271   for (Int_t i=0; i < fNCells; i++) 
272   {
273     newHGLG[i]      = fHGLG[idxArray[i]];
274     newIndex[i]     = fCellNumber[idxArray[i]];
275     newAmplitude[i] = fAmplitude [idxArray[i]];
276     if(fTime)      newTime[i]      = fTime     [idxArray[i]];
277     if(fMCLabel)   newMCLabel[i]   = fMCLabel  [idxArray[i]];
278     if(fEFraction) newEFraction[i] = fEFraction[idxArray[i]];  
279   }
280   
281   delete [] fHGLG;
282   delete [] fCellNumber;
283   delete [] fAmplitude;
284   delete [] fTime;
285   delete [] fMCLabel;
286   delete [] fEFraction;
287
288   fHGLG = newHGLG;
289   fCellNumber = newIndex;
290   fAmplitude  = newAmplitude;
291   if(fTime)      fTime       = newTime;
292   if(fMCLabel)   fMCLabel    = newMCLabel;
293   if(fEFraction) fEFraction  = newEFraction;
294
295   delete [] idxArray;
296   
297   fIsSorted = kTRUE;
298
299
300 //________________________________________________________________________________________
301 Bool_t AliAODCaloCells::SetCell(Short_t pos,     Short_t cellNumber, Double32_t amplitude, 
302                                 Double32_t time, Int_t mclabel,    Double32_t efrac, Bool_t isHG)
303 {
304   // Sets a cell at the given position
305
306   if (pos>=0 && pos < fNCells) 
307   {
308     fHGLG[pos]=isHG ;
309     fCellNumber[pos] = cellNumber;
310     fAmplitude[pos]  = amplitude;
311     
312     // note: initialize (can't use memset for non-0 values)
313     //       plus sizeof(Double32_t) is 0
314     if(!fTime){
315       fTime  = new Double32_t[fNCells];
316       
317       for( Int_t i = 0; i < fNCells; i++ )
318         fTime[i] = -1;
319     }
320     if(!fMCLabel){
321       fMCLabel = new Int_t[fNCells];
322       
323       for( Int_t i = 0; i < fNCells; i++ )
324         fMCLabel[i] = -1;
325     }
326     if(!fEFraction){
327       fEFraction = new Double32_t[fNCells];
328       
329       for( Int_t i = 0; i < fNCells; i++ )
330         fEFraction[i] = 0;
331     }
332     
333     fTime[pos]       = time;
334     fMCLabel[pos]    = mclabel;
335     fEFraction[pos]  = efrac;
336     
337     fIsSorted        = kFALSE;
338     
339     return kTRUE;
340     
341   } else {
342     return kFALSE;
343   }
344 }
345
346
347
348