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 AD data
18 : // Author: Michal Broz
19 : //-------------------------------------------------------------------------
20 :
21 : #include "AliESDAD.h"
22 : #include "AliLog.h"
23 :
24 172 : ClassImp(AliESDAD)
25 :
26 : //__________________________________________________________________________
27 : AliESDAD::AliESDAD()
28 45 : :AliVAD(),
29 45 : fBBtriggerADA(0),
30 45 : fBGtriggerADA(0),
31 45 : fBBtriggerADC(0),
32 45 : fBGtriggerADC(0),
33 45 : fADATime(-1024),
34 45 : fADCTime(-1024),
35 45 : fADATimeError(0),
36 45 : fADCTimeError(0),
37 45 : fADADecision(kADInvalid),
38 45 : fADCDecision(kADInvalid),
39 45 : fTriggerChargeA(0),
40 45 : fTriggerChargeC(0),
41 45 : fTriggerBits(0)
42 225 : {
43 : // Default constructor
44 1530 : for(Int_t j=0; j<16; j++){
45 720 : fMultiplicity[j] = 0.0;
46 720 : fAdc[j] = 0.0;
47 720 : fTime[j] = 0.0;
48 720 : fWidth[j] = 0.0;
49 720 : fBBFlag[j]= kFALSE;
50 720 : fBGFlag[j]= kFALSE;
51 31680 : for(Int_t k = 0; k < 21; ++k) fIsBB[j][k] = fIsBG[j][k] = kFALSE;
52 720 : fAdcTail[j] = 0.0;
53 720 : fAdcTrigger[j] = 0.0;
54 : }
55 90 : }
56 :
57 : //__________________________________________________________________________
58 : AliESDAD::AliESDAD(const AliESDAD &o)
59 0 : :AliVAD(o),
60 0 : fBBtriggerADA(o.fBBtriggerADA),
61 0 : fBGtriggerADA(o.fBGtriggerADA),
62 0 : fBBtriggerADC(o.fBBtriggerADC),
63 0 : fBGtriggerADC(o.fBGtriggerADC),
64 0 : fADATime(o.fADATime),
65 0 : fADCTime(o.fADCTime),
66 0 : fADATimeError(o.fADATimeError),
67 0 : fADCTimeError(o.fADCTimeError),
68 0 : fADADecision(o.fADADecision),
69 0 : fADCDecision(o.fADCDecision),
70 0 : fTriggerChargeA(o.fTriggerChargeA),
71 0 : fTriggerChargeC(o.fTriggerChargeC),
72 0 : fTriggerBits(o.fTriggerBits)
73 0 : {
74 : // Default constructor
75 0 : for(Int_t j=0; j<16; j++) {
76 0 : fMultiplicity[j] = o.fMultiplicity[j];
77 0 : fAdc[j] = o.fAdc[j];
78 0 : fTime[j] = o.fTime[j];
79 0 : fWidth[j] = o.fWidth[j];
80 0 : fBBFlag[j] = o.fBBFlag[j];
81 0 : fBGFlag[j] = o.fBGFlag[j];
82 0 : for(Int_t k = 0; k < 21; ++k) {
83 0 : fIsBB[j][k] = o.fIsBB[j][k];
84 0 : fIsBG[j][k] = o.fIsBG[j][k];
85 : }
86 0 : fAdcTail[j] = o.fAdcTail[j];
87 0 : fAdcTrigger[j] = o.fAdcTrigger[j];
88 : }
89 0 : }
90 :
91 : //__________________________________________________________________________
92 : AliESDAD::AliESDAD(UInt_t BBtriggerADA, UInt_t BGtriggerADA,
93 : UInt_t BBtriggerADC, UInt_t BGtriggerADC,
94 : Float_t *Multiplicity, Float_t *Adc,
95 : Float_t *Time, Float_t *Width, Bool_t *BBFlag, Bool_t *BGFlag)
96 0 : :AliVAD(),
97 0 : fBBtriggerADA(BBtriggerADA),
98 0 : fBGtriggerADA(BGtriggerADA),
99 0 : fBBtriggerADC(BBtriggerADC),
100 0 : fBGtriggerADC(BGtriggerADC),
101 0 : fADATime(-1024),
102 0 : fADCTime(-1024),
103 0 : fADATimeError(0),
104 0 : fADCTimeError(0),
105 0 : fADADecision(kADInvalid),
106 0 : fADCDecision(kADInvalid),
107 0 : fTriggerChargeA(0),
108 0 : fTriggerChargeC(0),
109 0 : fTriggerBits(0)
110 0 : {
111 : // Constructor
112 0 : for(Int_t j=0; j<16; j++) {
113 0 : fMultiplicity[j] = Multiplicity[j];
114 0 : fAdc[j] = Adc[j];
115 0 : fTime[j] = Time[j];
116 0 : fWidth[j] = Width[j];
117 0 : fBBFlag[j] = BBFlag[j];
118 0 : fBGFlag[j] = BGFlag[j];
119 0 : for(Int_t k = 0; k < 21; ++k) fIsBB[j][k] = fIsBG[j][k] = kFALSE;
120 0 : fAdcTail[j] = 0.0;
121 0 : fAdcTrigger[j] = 0.0;
122 : }
123 0 : }
124 :
125 : //__________________________________________________________________________
126 : AliESDAD& AliESDAD::operator=(const AliESDAD& o)
127 : {
128 :
129 0 : if(this==&o) return *this;
130 0 : AliVAD::operator=(o);
131 : // Assignment operator
132 0 : fBBtriggerADA=o.fBBtriggerADA;
133 0 : fBGtriggerADA=o.fBGtriggerADA;
134 0 : fBBtriggerADC=o.fBBtriggerADC;
135 0 : fBGtriggerADC=o.fBGtriggerADC;
136 :
137 0 : fADATime = o.fADATime;
138 0 : fADCTime = o.fADCTime;
139 0 : fADATimeError = o.fADATimeError;
140 0 : fADCTimeError = o.fADCTimeError;
141 0 : fADADecision = o.fADADecision;
142 0 : fADCDecision = o.fADCDecision;
143 0 : fTriggerChargeA = o.fTriggerChargeA;
144 0 : fTriggerChargeC = o.fTriggerChargeC;
145 0 : fTriggerBits = o.fTriggerBits;
146 :
147 0 : for(Int_t j=0; j<16; j++) {
148 0 : fMultiplicity[j] = o.fMultiplicity[j];
149 0 : fAdc[j] = o.fAdc[j];
150 0 : fTime[j] = o.fTime[j];
151 0 : fWidth[j] = o.fWidth[j];
152 0 : fBBFlag[j] = o.fBBFlag[j];
153 0 : fBGFlag[j] = o.fBGFlag[j];
154 0 : for(Int_t k = 0; k < 21; ++k) {
155 0 : fIsBB[j][k] = o.fIsBB[j][k];
156 0 : fIsBG[j][k] = o.fIsBG[j][k];
157 : }
158 0 : fAdcTail[j] = o.fAdcTail[j];
159 0 : fAdcTrigger[j] = o.fAdcTrigger[j];
160 : }
161 0 : return *this;
162 0 : }
163 :
164 : //______________________________________________________________________________
165 : void AliESDAD::Copy(TObject &obj) const {
166 :
167 : // this overwrites the virtual TOBject::Copy()
168 : // to allow run time copying without casting
169 : // in AliESDEvent
170 :
171 0 : if(this==&obj)return;
172 0 : AliESDAD *robj = dynamic_cast<AliESDAD*>(&obj);
173 0 : if(!robj)return; // not an AliESDAD
174 0 : *robj = *this;
175 :
176 0 : }
177 :
178 : //__________________________________________________________________________
179 : Short_t AliESDAD::GetNbPMADA() const
180 : {
181 : // Returns the number of
182 : // fired PM in ADA
183 : Short_t n=0;
184 0 : for(Int_t i=8;i<16;i++)
185 0 : if (fMultiplicity[i]>0) n++;
186 0 : return n;
187 : }
188 :
189 : //__________________________________________________________________________
190 : Short_t AliESDAD::GetNbPMADC() const
191 : {
192 : // Returns the number of
193 : // fired PM in ADC
194 : Short_t n=0;
195 0 : for(Int_t i=0;i<8;i++)
196 0 : if (fMultiplicity[i]>0) n++;
197 0 : return n;
198 : }
199 :
200 : //__________________________________________________________________________
201 : Float_t AliESDAD::GetMTotADA() const
202 : {
203 : // returns total multiplicity
204 : // in ADA
205 : Float_t mul=0.0;
206 0 : for(Int_t i=8;i<16;i++)
207 0 : mul+= fMultiplicity[i];
208 0 : return mul;
209 : }
210 :
211 : //__________________________________________________________________________
212 : Float_t AliESDAD::GetMTotADC() const
213 : {
214 : // returns total multiplicity
215 : // in ADC
216 : Float_t mul=0.0;
217 0 : for(Int_t i=0;i<8;i++)
218 0 : mul+= fMultiplicity[i];
219 0 : return mul;
220 : }
221 :
222 :
223 : //__________________________________________________________________________
224 : Float_t AliESDAD::GetMultiplicity(Int_t i) const
225 :
226 : {
227 : // returns multiplicity in a
228 : // given cell of AD
229 256 : if (OutOfRange(i, "AliESDAD::GetMultiplicity:",16)) return -1;
230 128 : return fMultiplicity[i];
231 128 : }
232 :
233 : //__________________________________________________________________________
234 : Float_t AliESDAD::GetMultiplicityADA(Int_t i) const
235 :
236 : {
237 : // returns multiplicity in a
238 : // given cell of ADA
239 0 : if (OutOfRange(i, "AliESDAD::GetMultiplicityADA:",8)) return -1;
240 0 : return fMultiplicity[8+i];
241 0 : }
242 :
243 : //__________________________________________________________________________
244 : Float_t AliESDAD::GetMultiplicityADC(Int_t i) const
245 :
246 : {
247 : // returns multiplicity in a
248 : // given cell of ADC
249 0 : if (OutOfRange(i, "AliESDAD::GetMultiplicityADC:",8)) return -1;
250 0 : return fMultiplicity[i];
251 0 : }
252 :
253 : //__________________________________________________________________________
254 : Float_t AliESDAD::GetAdc(Int_t i) const
255 :
256 : {
257 : // returns ADC charge in a
258 : // given cell of AD
259 0 : if (OutOfRange(i, "AliESDAD::GetAdc:",16)) return -1;
260 0 : return fAdc[i];
261 0 : }
262 :
263 : //__________________________________________________________________________
264 : Float_t AliESDAD::GetAdcADA(Int_t i) const
265 :
266 : {
267 : // returns ADC charge in a
268 : // given cell of ADA
269 0 : if (OutOfRange(i, "AliESDAD::GetAdcADA:",8)) return -1;
270 0 : return fAdc[8+i];
271 0 : }
272 :
273 : //__________________________________________________________________________
274 : Float_t AliESDAD::GetAdcADC(Int_t i) const
275 :
276 : {
277 : // returns ADC charge in a
278 : // given cell of ADC
279 0 : if (OutOfRange(i, "AliESDAD::GetAdcADC:",8)) return -1;
280 0 : return fAdc[i];
281 0 : }
282 :
283 : //__________________________________________________________________________
284 : Float_t AliESDAD::GetAdcTail(Int_t i) const
285 :
286 : {
287 : // returns ADC charge in a
288 : // given cell of AD
289 0 : if (OutOfRange(i, "AliESDAD::GetAdcTail:",16)) return -1;
290 0 : return fAdcTail[i];
291 0 : }
292 :
293 : //__________________________________________________________________________
294 : Float_t AliESDAD::GetAdcTailADA(Int_t i) const
295 :
296 : {
297 : // returns ADC charge in a
298 : // given cell of ADA
299 0 : if (OutOfRange(i, "AliESDAD::GetAdcTailADA:",8)) return -1;
300 0 : return fAdcTail[8+i];
301 0 : }
302 :
303 : //__________________________________________________________________________
304 : Float_t AliESDAD::GetAdcTailADC(Int_t i) const
305 :
306 : {
307 : // returns ADC charge in a
308 : // given cell of ADC
309 0 : if (OutOfRange(i, "AliESDAD::GetAdcTailADC:",8)) return -1;
310 0 : return fAdcTail[i];
311 0 : }
312 :
313 : //__________________________________________________________________________
314 : Float_t AliESDAD::GetAdcTrigger(Int_t i) const
315 :
316 : {
317 : // returns ADC charge in a
318 : // given cell of AD
319 0 : if (OutOfRange(i, "AliESDAD::GetAdcTrigger:",16)) return -1;
320 0 : return fAdcTrigger[i];
321 0 : }
322 :
323 : //__________________________________________________________________________
324 : Float_t AliESDAD::GetAdcTriggerADA(Int_t i) const
325 :
326 : {
327 : // returns ADC charge in a
328 : // given cell of ADA
329 0 : if (OutOfRange(i, "AliESDAD::GetAdcTriggerADA:",8)) return -1;
330 0 : return fAdcTrigger[8+i];
331 0 : }
332 :
333 : //__________________________________________________________________________
334 : Float_t AliESDAD::GetAdcTriggerADC(Int_t i) const
335 :
336 : {
337 : // returns ADC charge in a
338 : // given cell of ADC
339 0 : if (OutOfRange(i, "AliESDAD::GetAdcTriggerADC:",8)) return -1;
340 0 : return fAdcTrigger[i];
341 0 : }
342 :
343 :
344 :
345 : //__________________________________________________________________________
346 : Float_t AliESDAD::GetTime(Int_t i) const
347 :
348 : {
349 : // returns leading time measured by TDC
350 : // in a given cell of AD
351 0 : if (OutOfRange(i, "AliESDAD::GetTime:",16)) return -1;
352 0 : return fTime[i];
353 0 : }
354 :
355 : //__________________________________________________________________________
356 : Float_t AliESDAD::GetTimeADA(Int_t i) const
357 :
358 : {
359 : // returns leading time measured by TDC
360 : // in a given cell of ADA
361 0 : if (OutOfRange(i, "AliESDAD::GetTimeADA:",8)) return -1;
362 0 : return fTime[8+i];
363 0 : }
364 :
365 : //__________________________________________________________________________
366 : Float_t AliESDAD::GetTimeADC(Int_t i) const
367 :
368 : {
369 : // returns leading time measured by TDC
370 : // in a given cell of ADC
371 0 : if (OutOfRange(i, "AliESDAD::GetTimeADC:",8)) return -1;
372 0 : return fTime[i];
373 0 : }
374 :
375 : //__________________________________________________________________________
376 : Float_t AliESDAD::GetWidth(Int_t i) const
377 :
378 : {
379 : // returns time signal width
380 : // in a given cell of AD
381 0 : if (OutOfRange(i, "AliESDAD::GetWidth:",16)) return -1;
382 0 : return fWidth[i];
383 0 : }
384 :
385 : //__________________________________________________________________________
386 : Float_t AliESDAD::GetWidthADA(Int_t i) const
387 :
388 : {
389 : // returns time signal width
390 : // in a given cell of ADA
391 0 : if (OutOfRange(i, "AliESDAD::GetWidthADA:",8)) return -1;
392 0 : return fWidth[8+i];
393 0 : }
394 :
395 : //__________________________________________________________________________
396 : Float_t AliESDAD::GetWidthADC(Int_t i) const
397 :
398 : {
399 : // returns time signal width
400 : // in a given cell of ADC
401 0 : if (OutOfRange(i, "AliESDAD::GetWidthADC:",8)) return -1;
402 0 : return fWidth[i];
403 0 : }
404 :
405 : //__________________________________________________________________________
406 : Bool_t AliESDAD::BBTriggerADA(Int_t i) const
407 : {
408 : // returns offline beam-beam flags in ADA
409 : // one bit per cell
410 128 : if (OutOfRange(i, "AliESDAD:::BBTriggerADA",8)) return kFALSE;
411 : UInt_t test = 1;
412 64 : return ( fBBtriggerADA & (test << i) ? kTRUE : kFALSE );
413 64 : }
414 :
415 : //__________________________________________________________________________
416 : Bool_t AliESDAD::BGTriggerADA(Int_t i) const
417 : {
418 : // returns offline beam-gas flags in ADA
419 : // one bit per cell
420 128 : if (OutOfRange(i, "AliESDAD:::BGTriggerADA",8)) return kFALSE;
421 : UInt_t test = 1;
422 64 : return ( fBGtriggerADA & (test << i) ? kTRUE : kFALSE );
423 64 : }
424 :
425 : //__________________________________________________________________________
426 : Bool_t AliESDAD::BBTriggerADC(Int_t i) const
427 : {
428 : // returns offline beam-beam flags in ADC
429 : // one bit per cell
430 128 : if (OutOfRange(i, "AliESDAD:::BBTriggerADC",8)) return kFALSE;
431 : UInt_t test = 1;
432 64 : return ( fBBtriggerADC & (test << i) ? kTRUE : kFALSE );
433 64 : }
434 :
435 : //__________________________________________________________________________
436 : Bool_t AliESDAD::BGTriggerADC(Int_t i) const
437 : {
438 : // returns offline beam-gasflags in ADC
439 : // one bit per cell
440 128 : if (OutOfRange(i, "AliESDAD:::BGTriggerADC",8)) return kFALSE;
441 : UInt_t test = 1;
442 64 : return ( fBGtriggerADC & (test << i) ? kTRUE : kFALSE );
443 64 : }
444 :
445 : //__________________________________________________________________________
446 : Bool_t AliESDAD::GetBBFlag(Int_t i) const
447 :
448 : {
449 : // returns online beam-beam flag in AD
450 : // one boolean per cell
451 256 : if (OutOfRange(i, "AliESDAD::GetBBFlag:",16)) return kFALSE;
452 128 : return fBBFlag[i];
453 128 : }
454 :
455 : //__________________________________________________________________________
456 : Bool_t AliESDAD::GetBGFlag(Int_t i) const
457 :
458 : {
459 : // returns online beam-gas flag in AD
460 : // one boolean per cell
461 256 : if (OutOfRange(i, "AliESDAD::GetBGFlag:",16)) return kFALSE;
462 128 : return fBGFlag[i];
463 128 : }
|
