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