]>
Commit | Line | Data |
---|---|---|
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 | { | |
14 | // Default constructor | |
15 | for(Int_t j=0; j<64; j++){ | |
16 | fMultiplicity[j] = 0.0; | |
17 | fAdc[j] = 0; | |
18 | fTime[j] = 0; | |
19 | fWidth[j] = 0; | |
20 | fBBFlag[j]= kFALSE; | |
21 | fBGFlag[j]= kFALSE; | |
22 | } | |
23 | } | |
24 | ||
25 | //__________________________________________________________________________ | |
26 | AliESDVZERO::AliESDVZERO(const AliESDVZERO &o) | |
27 | :TObject(o), | |
28 | fBBtriggerV0A(o.fBBtriggerV0A), | |
29 | fBGtriggerV0A(o.fBGtriggerV0A), | |
30 | fBBtriggerV0C(o.fBBtriggerV0C), | |
31 | fBGtriggerV0C(o.fBGtriggerV0C) | |
32 | { | |
33 | // Default constructor | |
34 | for(Int_t j=0; j<64; j++) { | |
35 | fMultiplicity[j] = o.fMultiplicity[j]; | |
36 | fAdc[j] = o.fAdc[j]; | |
37 | fTime[j] = o.fTime[j]; | |
38 | fWidth[j] = o.fWidth[j]; | |
39 | fBBFlag[j] = o.fBBFlag[j]; | |
40 | fBGFlag[j] = o.fBGFlag[j]; | |
41 | } | |
42 | } | |
43 | ||
44 | //__________________________________________________________________________ | |
45 | AliESDVZERO::AliESDVZERO(UInt_t BBtriggerV0A, UInt_t BGtriggerV0A, | |
46 | UInt_t BBtriggerV0C, UInt_t BGtriggerV0C, | |
47 | Float_t *Multiplicity, Short_t *Adc, | |
48 | Short_t *Time, Short_t *Width, Bool_t *BBFlag, Bool_t *BGFlag) | |
49 | :TObject(), | |
50 | fBBtriggerV0A(BBtriggerV0A), | |
51 | fBGtriggerV0A(BGtriggerV0A), | |
52 | fBBtriggerV0C(BBtriggerV0C), | |
53 | fBGtriggerV0C(BGtriggerV0C) | |
54 | ||
55 | { | |
56 | // Constructor | |
57 | for(Int_t j=0; j<64; j++) { | |
58 | fMultiplicity[j] = Multiplicity[j]; | |
59 | fAdc[j] = Adc[j]; | |
60 | fTime[j] = Time[j]; | |
61 | fWidth[j] = Width[j]; | |
62 | fBBFlag[j] = BBFlag[j]; | |
63 | fBGFlag[j] = BGFlag[j]; | |
64 | } | |
65 | } | |
66 | ||
67 | //__________________________________________________________________________ | |
68 | AliESDVZERO& AliESDVZERO::operator=(const AliESDVZERO& o) | |
69 | { | |
70 | ||
71 | if(this==&o) return *this; | |
72 | TObject::operator=(o); | |
73 | // Assignment operator | |
74 | fBBtriggerV0A=o.fBBtriggerV0A; | |
75 | fBGtriggerV0A=o.fBGtriggerV0A; | |
76 | fBBtriggerV0C=o.fBBtriggerV0C; | |
77 | fBGtriggerV0C=o.fBGtriggerV0C; | |
78 | for(Int_t j=0; j<64; j++) { | |
79 | fMultiplicity[j] = o.fMultiplicity[j]; | |
80 | fAdc[j] = o.fAdc[j]; | |
81 | fTime[j] = o.fTime[j]; | |
82 | fWidth[j] = o.fWidth[j]; | |
83 | fBBFlag[j] = o.fBBFlag[j]; | |
84 | fBGFlag[j] = o.fBGFlag[j]; | |
85 | } | |
86 | return *this; | |
87 | } | |
88 | ||
89 | //__________________________________________________________________________ | |
90 | Short_t AliESDVZERO::GetNbPMV0A() | |
91 | { | |
92 | Short_t n=0; | |
93 | for(Int_t i=32;i<64;i++) | |
94 | if (fMultiplicity[i]>0) n++; | |
95 | return n; | |
96 | } | |
97 | ||
98 | //__________________________________________________________________________ | |
99 | Short_t AliESDVZERO::GetNbPMV0C() | |
100 | { | |
101 | Short_t n=0; | |
102 | for(Int_t i=0;i<32;i++) | |
103 | if (fMultiplicity[i]>0) n++; | |
104 | return n; | |
105 | } | |
106 | ||
107 | //__________________________________________________________________________ | |
108 | Float_t AliESDVZERO::GetMTotV0A() | |
109 | { | |
110 | Float_t mul=0.0; | |
111 | for(Int_t i=32;i<64;i++) | |
112 | mul+= (Float_t) fMultiplicity[i]; | |
113 | return mul; | |
114 | } | |
115 | ||
116 | //__________________________________________________________________________ | |
117 | Float_t AliESDVZERO::GetMTotV0C() | |
118 | { | |
119 | Float_t mul=0.0; | |
120 | for(Int_t i=0;i<32;i++) | |
121 | mul+= (Float_t) fMultiplicity[i]; | |
122 | return mul; | |
123 | } | |
124 | ||
125 | //__________________________________________________________________________ | |
126 | Float_t* AliESDVZERO::GetMRingV0A() | |
127 | { | |
128 | // cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl; | |
129 | // cout << "use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)" << endl; | |
130 | AliInfo("AliESDVZERO::GetMRingV0C() not supported any more"); | |
131 | AliInfo("use Float_t AliESDVZERO::GetMRingV0C(Int_t ring)"); | |
132 | return 0x0; | |
133 | } | |
134 | ||
135 | //__________________________________________________________________________ | |
136 | Float_t* AliESDVZERO::GetMRingV0C() | |
137 | { | |
138 | // cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl; | |
139 | // cout << "use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)" << endl; | |
140 | AliInfo("AliESDVZERO::GetMRingV0C() not supported any more"); | |
141 | AliInfo("use Float_t AliESDVZERO::GetMRingV0C(Int_t ring)"); | |
142 | return 0x0; | |
143 | } | |
144 | ||
145 | //__________________________________________________________________________ | |
146 | Float_t AliESDVZERO::GetMRingV0A(Int_t ring) | |
147 | { | |
148 | if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0A",4)) return -1; | |
149 | Float_t mul =0.0; | |
150 | ||
151 | if (ring == 0) for(Int_t i=32;i<40;i++) mul += (Float_t) fMultiplicity[i]; | |
152 | if (ring == 1) for(Int_t i=40;i<48;i++) mul += (Float_t) fMultiplicity[i]; | |
153 | if (ring == 2) for(Int_t i=48;i<56;i++) mul += (Float_t) fMultiplicity[i]; | |
154 | if (ring == 3) for(Int_t i=56;i<64;i++) mul += (Float_t) fMultiplicity[i]; | |
155 | return mul ; | |
156 | } | |
157 | ||
158 | //__________________________________________________________________________ | |
159 | Float_t AliESDVZERO::GetMRingV0C(Int_t ring) | |
160 | { | |
161 | if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0C",4)) return -1; | |
162 | Float_t mul =0.0; | |
163 | ||
164 | if (ring == 0) for(Int_t i=0;i<8;i++) mul += (Float_t) fMultiplicity[i]; | |
165 | if (ring == 1) for(Int_t i=8;i<16;i++) mul += (Float_t) fMultiplicity[i]; | |
166 | if (ring == 2) for(Int_t i=16;i<24;i++) mul += (Float_t) fMultiplicity[i]; | |
167 | if (ring == 3) for(Int_t i=24;i<32;i++) mul += (Float_t) fMultiplicity[i]; | |
168 | return mul ; | |
169 | } | |
170 | ||
171 | //__________________________________________________________________________ | |
172 | Float_t AliESDVZERO::GetMultiplicity(Int_t i) | |
173 | ||
174 | { | |
175 | if (OutOfRange(i, "AliESDVZERO::GetMultiplicity:",64)) return -1; | |
176 | return fMultiplicity[i]; | |
177 | } | |
178 | ||
179 | //__________________________________________________________________________ | |
180 | Float_t AliESDVZERO::GetMultiplicityV0A(Int_t i) | |
181 | ||
182 | { | |
183 | if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0A:",32)) return -1; | |
184 | return fMultiplicity[32+i]; | |
185 | } | |
186 | ||
187 | //__________________________________________________________________________ | |
188 | Float_t AliESDVZERO::GetMultiplicityV0C(Int_t i) | |
189 | ||
190 | { | |
191 | if (OutOfRange(i, "AliESDVZERO::GetMultiplicityV0C:",32)) return -1; | |
192 | return fMultiplicity[i]; | |
193 | } | |
194 | ||
195 | //__________________________________________________________________________ | |
196 | Int_t AliESDVZERO::GetAdc(Int_t i) | |
197 | ||
198 | { | |
199 | if (OutOfRange(i, "AliESDVZERO::GetAdc:",64)) return -1; | |
200 | return fAdc[i]; | |
201 | } | |
202 | ||
203 | //__________________________________________________________________________ | |
204 | Int_t AliESDVZERO::GetAdcV0A(Int_t i) | |
205 | ||
206 | { | |
207 | if (OutOfRange(i, "AliESDVZERO::GetAdcV0A:",32)) return -1; | |
208 | return fAdc[32+i]; | |
209 | } | |
210 | ||
211 | //__________________________________________________________________________ | |
212 | Int_t AliESDVZERO::GetAdcV0C(Int_t i) | |
213 | ||
214 | { | |
215 | if (OutOfRange(i, "AliESDVZERO::GetAdcV0C:",32)) return -1; | |
216 | return fAdc[i]; | |
217 | } | |
218 | ||
219 | //__________________________________________________________________________ | |
220 | Int_t AliESDVZERO::GetTime(Int_t i) | |
221 | ||
222 | { | |
223 | if (OutOfRange(i, "AliESDVZERO::GetTime:",64)) return -1; | |
224 | return fTime[i]; | |
225 | } | |
226 | ||
227 | //__________________________________________________________________________ | |
228 | Int_t AliESDVZERO::GetTimeV0A(Int_t i) | |
229 | ||
230 | { | |
231 | if (OutOfRange(i, "AliESDVZERO::GetTimeV0A:",32)) return -1; | |
232 | return fTime[32+i]; | |
233 | } | |
234 | ||
235 | //__________________________________________________________________________ | |
236 | Int_t AliESDVZERO::GetTimeV0C(Int_t i) | |
237 | ||
238 | { | |
239 | if (OutOfRange(i, "AliESDVZERO::GetTimeV0C:",32)) return -1; | |
240 | return fTime[i]; | |
241 | } | |
242 | ||
243 | //__________________________________________________________________________ | |
244 | Int_t AliESDVZERO::GetWidth(Int_t i) | |
245 | ||
246 | { | |
247 | if (OutOfRange(i, "AliESDVZERO::GetWidth:",64)) return -1; | |
248 | return fWidth[i]; | |
249 | } | |
250 | ||
251 | //__________________________________________________________________________ | |
252 | Int_t AliESDVZERO::GetWidthV0A(Int_t i) | |
253 | ||
254 | { | |
255 | if (OutOfRange(i, "AliESDVZERO::GetWidthV0A:",32)) return -1; | |
256 | return fWidth[32+i]; | |
257 | } | |
258 | ||
259 | //__________________________________________________________________________ | |
260 | Int_t AliESDVZERO::GetWidthV0C(Int_t i) | |
261 | ||
262 | { | |
263 | if (OutOfRange(i, "AliESDVZERO::GetWidthV0C:",32)) return -1; | |
264 | return fWidth[i]; | |
265 | } | |
266 | ||
267 | //__________________________________________________________________________ | |
268 | Bool_t AliESDVZERO::BBTriggerV0A(Int_t i) | |
269 | { | |
270 | if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0A",32)) return kFALSE; | |
271 | UInt_t test = 1; | |
272 | return ( fBBtriggerV0A & (test << i) ? kTRUE : kFALSE ); | |
273 | } | |
274 | ||
275 | //__________________________________________________________________________ | |
276 | Bool_t AliESDVZERO::BGTriggerV0A(Int_t i) | |
277 | { | |
278 | if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0A",32)) return kFALSE; | |
279 | UInt_t test = 1; | |
280 | return ( fBGtriggerV0A & (test << i) ? kTRUE : kFALSE ); | |
281 | } | |
282 | ||
283 | //__________________________________________________________________________ | |
284 | Bool_t AliESDVZERO::BBTriggerV0C(Int_t i) | |
285 | { | |
286 | if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0C",32)) return kFALSE; | |
287 | UInt_t test = 1; | |
288 | return ( fBBtriggerV0C & (test << i) ? kTRUE : kFALSE ); | |
289 | } | |
290 | ||
291 | //__________________________________________________________________________ | |
292 | Bool_t AliESDVZERO::BGTriggerV0C(Int_t i) | |
293 | { | |
294 | if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0C",32)) return kFALSE; | |
295 | UInt_t test = 1; | |
296 | return ( fBGtriggerV0C & (test << i) ? kTRUE : kFALSE ); | |
297 | } | |
298 | ||
299 | //__________________________________________________________________________ | |
300 | Bool_t AliESDVZERO::GetBBFlag(Int_t i) | |
301 | ||
302 | { | |
303 | if (OutOfRange(i, "AliESDVZERO::GetBBFlag:",64)) return kFALSE; | |
304 | return fBBFlag[i]; | |
305 | } | |
306 | ||
307 | //__________________________________________________________________________ | |
308 | Bool_t AliESDVZERO::GetBGFlag(Int_t i) | |
309 | ||
310 | { | |
311 | if (OutOfRange(i, "AliESDVZERO::GetBGFlag:",64)) return kFALSE; | |
312 | return fBGFlag[i]; | |
313 | } | |
314 | ||
315 | //__________________________________________________________________________ | |
316 | Bool_t AliESDVZERO::OutOfRange(Int_t i, const char* /*s*/, Int_t upper) const | |
317 | { | |
318 | // checks if i is a valid index. s = name of calling method | |
319 | if (i > upper || i < 0) { | |
320 | // cout << s << " Index " << i << " out of range" << endl; | |
321 | AliInfo(Form("Index %d out of range",i)); | |
322 | return kTRUE; | |
323 | } | |
324 | return kFALSE; | |
325 | } | |
326 |