In AddTaskPHOSPi0Flow.C set Cent. Bin past event buffers/lists,
[u/mrichter/AliRoot.git] / STEER / ESD / AliESDVZERO.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 //-------------------------------------------------------------------------
17 //     Container class for ESD VZERO data
18 //     Author: Brigitte Cheynis & Cvetan Cheshkov
19 //-------------------------------------------------------------------------
20
21 #include "AliESDVZERO.h"
22 #include "AliLog.h"
23
24 ClassImp(AliESDVZERO)
25
26 //__________________________________________________________________________
27 AliESDVZERO::AliESDVZERO()
28   :AliVVZERO(),
29    fBBtriggerV0A(0),
30    fBGtriggerV0A(0),
31    fBBtriggerV0C(0),
32    fBGtriggerV0C(0),
33    fV0ATime(-1024),
34    fV0CTime(-1024),
35    fV0ATimeError(0),
36    fV0CTimeError(0),
37    fV0ADecision(kV0Invalid),
38    fV0CDecision(kV0Invalid),
39    fTriggerChargeA(0),
40    fTriggerChargeC(0),
41    fTriggerBits(0)
42 {   
43    // Default constructor 
44    for(Int_t j=0; j<64; j++){ 
45       fMultiplicity[j] = 0.0;   
46       fAdc[j]   = 0.0;   
47       fTime[j]  = 0.0; 
48       fWidth[j] = 0.0; 
49       fBBFlag[j]= kFALSE;
50       fBGFlag[j]= kFALSE;  
51    }
52 }
53
54 //__________________________________________________________________________
55 AliESDVZERO::AliESDVZERO(const AliESDVZERO &o)
56   :AliVVZERO(o),
57    fBBtriggerV0A(o.fBBtriggerV0A),
58    fBGtriggerV0A(o.fBGtriggerV0A),
59    fBBtriggerV0C(o.fBBtriggerV0C),
60    fBGtriggerV0C(o.fBGtriggerV0C),
61    fV0ATime(o.fV0ATime),
62    fV0CTime(o.fV0CTime),
63    fV0ATimeError(o.fV0ATimeError),
64    fV0CTimeError(o.fV0CTimeError),
65    fV0ADecision(o.fV0ADecision),
66    fV0CDecision(o.fV0CDecision),
67    fTriggerChargeA(o.fTriggerChargeA),
68    fTriggerChargeC(o.fTriggerChargeC),
69    fTriggerBits(o.fTriggerBits)
70 {   
71    // Default constructor 
72    for(Int_t j=0; j<64; j++) {
73        fMultiplicity[j] = o.fMultiplicity[j];
74        fAdc[j]    = o.fAdc[j];
75        fTime[j]   = o.fTime[j];
76        fWidth[j]  = o.fWidth[j];
77        fBBFlag[j] = o.fBBFlag[j];
78        fBGFlag[j] = o.fBGFlag[j];
79    }
80 }
81
82 //__________________________________________________________________________
83 AliESDVZERO::AliESDVZERO(UInt_t BBtriggerV0A, UInt_t BGtriggerV0A,
84               UInt_t BBtriggerV0C, UInt_t BGtriggerV0C,
85               Float_t *Multiplicity, Float_t *Adc, 
86               Float_t *Time, Float_t *Width, Bool_t *BBFlag, Bool_t *BGFlag)
87   :AliVVZERO(),
88    fBBtriggerV0A(BBtriggerV0A),
89    fBGtriggerV0A(BGtriggerV0A),
90    fBBtriggerV0C(BBtriggerV0C),
91    fBGtriggerV0C(BGtriggerV0C),
92    fV0ATime(-1024),
93    fV0CTime(-1024),
94    fV0ATimeError(0),
95    fV0CTimeError(0),
96    fV0ADecision(kV0Invalid),
97    fV0CDecision(kV0Invalid),
98    fTriggerChargeA(0),
99    fTriggerChargeC(0),
100    fTriggerBits(0)
101 {
102    // Constructor
103    for(Int_t j=0; j<64; j++) {
104        fMultiplicity[j] = Multiplicity[j];
105        fAdc[j]    = Adc[j];
106        fTime[j]   = Time[j];
107        fWidth[j]  = Width[j];
108        fBBFlag[j] = BBFlag[j];
109        fBGFlag[j] = BGFlag[j];
110    }
111 }
112
113 //__________________________________________________________________________
114 AliESDVZERO& AliESDVZERO::operator=(const AliESDVZERO& o)
115 {
116
117   if(this==&o) return *this;
118   AliVVZERO::operator=(o);
119   // Assignment operator
120   fBBtriggerV0A=o.fBBtriggerV0A;
121   fBGtriggerV0A=o.fBGtriggerV0A;
122   fBBtriggerV0C=o.fBBtriggerV0C;
123   fBGtriggerV0C=o.fBGtriggerV0C;
124
125   fV0ATime = o.fV0ATime;
126   fV0CTime = o.fV0CTime;
127   fV0ATimeError = o.fV0ATimeError;
128   fV0CTimeError = o.fV0CTimeError;
129   fV0ADecision = o.fV0ADecision;
130   fV0CDecision = o.fV0CDecision;
131   fTriggerChargeA = o.fTriggerChargeA;
132   fTriggerChargeC = o.fTriggerChargeC;
133   fTriggerBits = o.fTriggerBits;
134
135    for(Int_t j=0; j<64; j++) {
136        fMultiplicity[j] = o.fMultiplicity[j];
137        fAdc[j]    = o.fAdc[j];
138        fTime[j]   = o.fTime[j];
139        fWidth[j]  = o.fWidth[j];
140        fBBFlag[j] = o.fBBFlag[j];
141        fBGFlag[j] = o.fBGFlag[j];
142    }
143   return *this;
144 }
145
146 //______________________________________________________________________________
147 void AliESDVZERO::Copy(TObject &obj) const {
148   
149   // this overwrites the virtual TOBject::Copy()
150   // to allow run time copying without casting
151   // in AliESDEvent
152
153   if(this==&obj)return;
154   AliESDVZERO *robj = dynamic_cast<AliESDVZERO*>(&obj);
155   if(!robj)return; // not an AliESDVZERO
156   *robj = *this;
157
158 }
159
160 //__________________________________________________________________________
161 Short_t AliESDVZERO::GetNbPMV0A() const
162 {
163   // Returns the number of
164   // fired PM in V0A
165   Short_t n=0;
166   for(Int_t i=32;i<64;i++) 
167     if (fMultiplicity[i]>0) n++;
168   return n;
169 }
170
171 //__________________________________________________________________________
172 Short_t AliESDVZERO::GetNbPMV0C() const
173 {
174   // Returns the number of
175   // fired PM in V0C
176   Short_t n=0;
177   for(Int_t i=0;i<32;i++) 
178     if (fMultiplicity[i]>0) n++;
179   return n;
180 }
181
182 //__________________________________________________________________________
183 Float_t AliESDVZERO::GetMTotV0A() const
184 {
185   // returns total multiplicity
186   // in V0A
187   Float_t mul=0.0;
188   for(Int_t i=32;i<64;i++) 
189     mul+=  fMultiplicity[i];
190   return mul;
191 }
192
193 //__________________________________________________________________________
194 Float_t AliESDVZERO::GetMTotV0C() const
195 {
196   // returns total multiplicity
197   // in V0C
198   Float_t mul=0.0;
199   for(Int_t i=0;i<32;i++) 
200     mul+=  fMultiplicity[i];
201   return mul;
202 }
203
204 //__________________________________________________________________________
205 Float_t AliESDVZERO::GetMRingV0A(Int_t ring) const
206
207   // returns multiplicity in a
208   // given ring of V0A
209   if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0A",4)) return -1;
210   Float_t mul =0.0;
211
212   if (ring == 0) for(Int_t i=32;i<40;i++) mul +=  fMultiplicity[i];
213   if (ring == 1) for(Int_t i=40;i<48;i++) mul +=  fMultiplicity[i];
214   if (ring == 2) for(Int_t i=48;i<56;i++) mul +=  fMultiplicity[i];
215   if (ring == 3) for(Int_t i=56;i<64;i++) mul +=  fMultiplicity[i];
216   return mul ;
217 }
218
219 //__________________________________________________________________________
220 Float_t AliESDVZERO::GetMRingV0C(Int_t ring) const
221
222   // returns multiplicity in a
223   // given ring of V0C
224   if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0C",4)) return -1;
225   Float_t mul =0.0;
226
227   if (ring == 0) for(Int_t i=0;i<8;i++)   mul +=  fMultiplicity[i];
228   if (ring == 1) for(Int_t i=8;i<16;i++)  mul +=  fMultiplicity[i];
229   if (ring == 2) for(Int_t i=16;i<24;i++) mul +=  fMultiplicity[i];
230   if (ring == 3) for(Int_t i=24;i<32;i++) mul +=  fMultiplicity[i];
231   return mul ;
232 }
233
234 //__________________________________________________________________________
235 Float_t AliESDVZERO::GetMultiplicity(Int_t i) const
236
237 {
238   // returns multiplicity in a
239   // given cell of V0
240   if (OutOfRange(i, "AliESDVZERO::GetMultiplicity:",64)) return -1;
241   return fMultiplicity[i];
242 }
243
244 //__________________________________________________________________________
245 Float_t AliESDVZERO::GetMultiplicityV0A(Int_t i) const
246
247 {
248   // returns multiplicity in a
249   // given cell of V0A
250   if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0A:",32)) return -1;
251   return fMultiplicity[32+i];
252 }
253
254 //__________________________________________________________________________
255 Float_t AliESDVZERO::GetMultiplicityV0C(Int_t i) const
256
257 {
258   // returns multiplicity in a
259   // given cell of V0C
260   if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0C:",32)) return -1;
261   return fMultiplicity[i];
262 }
263
264 //__________________________________________________________________________
265 Float_t AliESDVZERO::GetAdc(Int_t i) const
266
267 {
268   // returns ADC charge in a
269   // given cell of V0
270   if (OutOfRange(i, "AliESDVZERO::GetAdc:",64)) return -1;
271   return fAdc[i];
272 }
273
274 //__________________________________________________________________________
275 Float_t AliESDVZERO::GetAdcV0A(Int_t i) const
276
277 {
278   // returns ADC charge in a
279   // given cell of V0A
280   if (OutOfRange(i, "AliESDVZERO::GetAdcV0A:",32)) return -1;
281   return fAdc[32+i];
282 }
283
284 //__________________________________________________________________________
285 Float_t AliESDVZERO::GetAdcV0C(Int_t i) const
286
287 {
288   // returns ADC charge in a
289   // given cell of V0C
290   if (OutOfRange(i, "AliESDVZERO::GetAdcV0C:",32)) return -1;
291   return fAdc[i];
292 }
293
294 //__________________________________________________________________________
295 Float_t AliESDVZERO::GetTime(Int_t i) const
296
297 {
298   // returns leading time measured by TDC
299   // in a given cell of V0
300   if (OutOfRange(i, "AliESDVZERO::GetTime:",64)) return -1;
301   return fTime[i];
302 }
303
304 //__________________________________________________________________________
305 Float_t AliESDVZERO::GetTimeV0A(Int_t i) const
306
307 {
308   // returns leading time measured by TDC
309   // in a given cell of V0A
310   if (OutOfRange(i, "AliESDVZERO::GetTimeV0A:",32)) return -1;
311   return fTime[32+i];
312 }
313
314 //__________________________________________________________________________
315 Float_t AliESDVZERO::GetTimeV0C(Int_t i) const
316
317 {
318   // returns leading time measured by TDC
319   // in a given cell of V0C
320   if (OutOfRange(i, "AliESDVZERO::GetTimeV0C:",32)) return -1;
321   return fTime[i];
322 }
323
324 //__________________________________________________________________________
325 Float_t AliESDVZERO::GetWidth(Int_t i) const
326
327 {
328   // returns time signal width
329   // in a given cell of V0
330   if (OutOfRange(i, "AliESDVZERO::GetWidth:",64)) return -1;
331   return fWidth[i];
332 }
333
334 //__________________________________________________________________________
335 Float_t AliESDVZERO::GetWidthV0A(Int_t i) const
336
337 {
338   // returns time signal width
339   // in a given cell of V0A
340   if (OutOfRange(i, "AliESDVZERO::GetWidthV0A:",32)) return -1;
341   return fWidth[32+i];
342 }
343
344 //__________________________________________________________________________
345 Float_t AliESDVZERO::GetWidthV0C(Int_t i) const
346
347 {
348   // returns time signal width
349   // in a given cell of V0C
350   if (OutOfRange(i, "AliESDVZERO::GetWidthV0C:",32)) return -1;
351   return fWidth[i];
352 }
353
354 //__________________________________________________________________________
355 Bool_t AliESDVZERO::BBTriggerV0A(Int_t i) const
356 {
357   // returns offline beam-beam flags in V0A
358   // one bit per cell
359   if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0A",32)) return kFALSE;
360   UInt_t test = 1;
361   return ( fBBtriggerV0A & (test << i) ? kTRUE : kFALSE );
362 }
363
364 //__________________________________________________________________________
365 Bool_t AliESDVZERO::BGTriggerV0A(Int_t i) const
366 {
367   // returns offline beam-gas flags in V0A
368   // one bit per cell
369   if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0A",32)) return kFALSE;
370   UInt_t test = 1;
371   return ( fBGtriggerV0A & (test << i) ? kTRUE : kFALSE );
372 }
373
374 //__________________________________________________________________________
375 Bool_t AliESDVZERO::BBTriggerV0C(Int_t i) const
376 {
377   // returns offline beam-beam flags in V0C
378   // one bit per cell
379   if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0C",32)) return kFALSE;
380   UInt_t test = 1;
381   return ( fBBtriggerV0C & (test << i) ? kTRUE : kFALSE );
382 }
383
384 //__________________________________________________________________________
385 Bool_t AliESDVZERO::BGTriggerV0C(Int_t i) const
386 {
387   // returns offline beam-gasflags in V0C
388   // one bit per cell
389   if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0C",32)) return kFALSE;
390   UInt_t test = 1;
391   return ( fBGtriggerV0C & (test << i) ? kTRUE : kFALSE );
392 }
393
394 //__________________________________________________________________________
395 Bool_t AliESDVZERO::GetBBFlag(Int_t i) const
396
397 {
398   // returns online beam-beam flag in V0
399   // one boolean per cell
400   if (OutOfRange(i, "AliESDVZERO::GetBBFlag:",64)) return kFALSE;
401   return fBBFlag[i];
402 }
403
404 //__________________________________________________________________________
405 Bool_t AliESDVZERO::GetBGFlag(Int_t i) const
406
407 {
408   // returns online beam-gas flag in V0
409   // one boolean per cell
410   if (OutOfRange(i, "AliESDVZERO::GetBGFlag:",64)) return kFALSE;
411   return fBGFlag[i];
412 }