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