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 AOD VZERO data
18 : // Author: Cvetan Cheshkov
19 : // cvetan.cheshkov@cern.ch 2/02/2011
20 : //-------------------------------------------------------------------------
21 :
22 : #include "AliAODVZERO.h"
23 : #include "AliLog.h"
24 :
25 170 : ClassImp(AliAODVZERO)
26 :
27 : //__________________________________________________________________________
28 : AliAODVZERO::AliAODVZERO()
29 2 : :AliVVZERO(),
30 2 : fBBtriggerV0A(0),
31 2 : fBGtriggerV0A(0),
32 2 : fBBtriggerV0C(0),
33 2 : fBGtriggerV0C(0),
34 2 : fV0ATime(-1024),
35 2 : fV0CTime(-1024),
36 2 : fV0ADecision(kV0Invalid),
37 2 : fV0CDecision(kV0Invalid),
38 2 : fTriggerChargeA(0),
39 2 : fTriggerChargeC(0),
40 2 : fTriggerBits(0)
41 10 : {
42 : // Default constructor
43 260 : for(Int_t j=0; j<64; j++){
44 128 : fMultiplicity[j] = 0.0;
45 128 : fBBFlag[j]= kFALSE;
46 128 : fBGFlag[j]= kFALSE;
47 5632 : for(Int_t k = 0; k < 21; ++k) fIsBB[j][k] = fIsBG[j][k] = kFALSE;
48 : }
49 4 : }
50 :
51 : //__________________________________________________________________________
52 : AliAODVZERO::AliAODVZERO(const AliAODVZERO &source)
53 0 : :AliVVZERO(source),
54 0 : fBBtriggerV0A(source.fBBtriggerV0A),
55 0 : fBGtriggerV0A(source.fBGtriggerV0A),
56 0 : fBBtriggerV0C(source.fBBtriggerV0C),
57 0 : fBGtriggerV0C(source.fBGtriggerV0C),
58 0 : fV0ATime(source.fV0ATime),
59 0 : fV0CTime(source.fV0CTime),
60 0 : fV0ADecision(source.fV0ADecision),
61 0 : fV0CDecision(source.fV0CDecision),
62 0 : fTriggerChargeA(source.fTriggerChargeA),
63 0 : fTriggerChargeC(source.fTriggerChargeC),
64 0 : fTriggerBits(source.fTriggerBits)
65 0 : {
66 : // Default constructor
67 0 : for(Int_t j=0; j<64; j++) {
68 0 : fMultiplicity[j] = source.fMultiplicity[j];
69 0 : fBBFlag[j] = source.fBBFlag[j];
70 0 : fBGFlag[j] = source.fBGFlag[j];
71 0 : for(Int_t k = 0; k < 21; ++k) {
72 0 : fIsBB[j][k] = source.fIsBB[j][k];
73 0 : fIsBG[j][k] = source.fIsBG[j][k];
74 : }
75 : }
76 0 : }
77 :
78 : //__________________________________________________________________________
79 : AliAODVZERO::AliAODVZERO(const AliVVZERO &source)
80 0 : :AliVVZERO(source),
81 0 : fBBtriggerV0A(0),
82 0 : fBGtriggerV0A(0),
83 0 : fBBtriggerV0C(0),
84 0 : fBGtriggerV0C(0),
85 0 : fV0ATime(source.GetV0ATime()),
86 0 : fV0CTime(source.GetV0CTime()),
87 0 : fV0ADecision(source.GetV0ADecision()),
88 0 : fV0CDecision(source.GetV0CDecision()),
89 0 : fTriggerChargeA(source.GetTriggerChargeA()),
90 0 : fTriggerChargeC(source.GetTriggerChargeC()),
91 0 : fTriggerBits(source.GetTriggerBits())
92 0 : {
93 : // Default constructor
94 0 : for(Int_t j=0; j<64; j++) {
95 0 : fMultiplicity[j] = source.GetMultiplicity(j);
96 0 : fBBFlag[j] = source.GetBBFlag(j);
97 0 : fBGFlag[j] = source.GetBGFlag(j);
98 0 : for(Int_t k = 0; k < 21; ++k) {
99 0 : fIsBB[j][k] = source.GetPFBBFlag(j,k);
100 0 : fIsBG[j][k] = source.GetPFBGFlag(j,k);
101 : }
102 : }
103 :
104 0 : for(Int_t j=0; j<32; j++) {
105 0 : if (source.BBTriggerV0A(j)) fBBtriggerV0A |= (1 << j);
106 0 : if (source.BGTriggerV0A(j)) fBGtriggerV0A |= (1 << j);
107 0 : if (source.BBTriggerV0C(j)) fBBtriggerV0C |= (1 << j);
108 0 : if (source.BGTriggerV0C(j)) fBGtriggerV0C |= (1 << j);
109 : }
110 0 : }
111 :
112 : //__________________________________________________________________________
113 : AliAODVZERO& AliAODVZERO::operator=(const AliAODVZERO& source)
114 : {
115 : // Assignment operator
116 : //
117 0 : if(this==&source) return *this;
118 0 : AliVVZERO::operator=(source);
119 : // Assignment operator
120 0 : fBBtriggerV0A=source.fBBtriggerV0A;
121 0 : fBGtriggerV0A=source.fBGtriggerV0A;
122 0 : fBBtriggerV0C=source.fBBtriggerV0C;
123 0 : fBGtriggerV0C=source.fBGtriggerV0C;
124 :
125 0 : fV0ATime = source.fV0ATime;
126 0 : fV0CTime = source.fV0CTime;
127 0 : fV0ADecision = source.fV0ADecision;
128 0 : fV0CDecision = source.fV0CDecision;
129 0 : fTriggerChargeA = source.fTriggerChargeA;
130 0 : fTriggerChargeC = source.fTriggerChargeC;
131 0 : fTriggerBits = source.fTriggerBits;
132 :
133 0 : for(Int_t j=0; j<64; j++) {
134 0 : fMultiplicity[j] = source.fMultiplicity[j];
135 0 : fBBFlag[j] = source.fBBFlag[j];
136 0 : fBGFlag[j] = source.fBGFlag[j];
137 0 : for(Int_t k = 0; k < 21; ++k) {
138 0 : fIsBB[j][k] = source.fIsBB[j][k];
139 0 : fIsBG[j][k] = source.fIsBG[j][k];
140 : }
141 : }
142 0 : return *this;
143 0 : }
144 :
145 : //__________________________________________________________________________
146 : AliAODVZERO& AliAODVZERO::operator=(const AliVVZERO& source)
147 : {
148 : // Assignment operator
149 : // used in esd->aod filter
150 16 : if(this==&source) return *this;
151 8 : AliVVZERO::operator=(source);
152 :
153 8 : fV0ATime = source.GetV0ATime();
154 8 : fV0CTime = source.GetV0CTime();
155 8 : fV0ADecision = source.GetV0ADecision();
156 8 : fV0CDecision = source.GetV0CDecision();
157 8 : fTriggerChargeA = source.GetTriggerChargeA();
158 8 : fTriggerChargeC = source.GetTriggerChargeC();
159 8 : fTriggerBits = source.GetTriggerBits();
160 :
161 1040 : for(Int_t j=0; j<64; j++) {
162 512 : fMultiplicity[j] = source.GetMultiplicity(j);
163 512 : fBBFlag[j] = source.GetBBFlag(j);
164 512 : fBGFlag[j] = source.GetBGFlag(j);
165 22528 : for(Int_t k = 0; k < 21; ++k) {
166 10752 : fIsBB[j][k] = source.GetPFBBFlag(j,k);
167 10752 : fIsBG[j][k] = source.GetPFBGFlag(j,k);
168 : }
169 : }
170 :
171 8 : fBBtriggerV0A = fBGtriggerV0A = fBBtriggerV0C = fBGtriggerV0C = 0;
172 528 : for(Int_t j=0; j<32; j++) {
173 304 : if (source.BBTriggerV0A(j)) fBBtriggerV0A |= (1 << j);
174 256 : if (source.BGTriggerV0A(j)) fBGtriggerV0A |= (1 << j);
175 290 : if (source.BBTriggerV0C(j)) fBBtriggerV0C |= (1 << j);
176 256 : if (source.BGTriggerV0C(j)) fBGtriggerV0C |= (1 << j);
177 : }
178 :
179 8 : return *this;
180 :
181 8 : }
182 :
183 : //__________________________________________________________________________
184 : Short_t AliAODVZERO::GetNbPMV0A() const
185 : {
186 : // Returns the number of
187 : // fired PM in V0A
188 : Short_t n=0;
189 0 : for(Int_t i=32;i<64;i++)
190 0 : if (fMultiplicity[i]>0) n++;
191 0 : return n;
192 : }
193 :
194 : //__________________________________________________________________________
195 : Short_t AliAODVZERO::GetNbPMV0C() const
196 : {
197 : // Returns the number of
198 : // fired PM in V0C
199 : Short_t n=0;
200 0 : for(Int_t i=0;i<32;i++)
201 0 : if (fMultiplicity[i]>0) n++;
202 0 : return n;
203 : }
204 :
205 : //__________________________________________________________________________
206 : Float_t AliAODVZERO::GetMTotV0A() const
207 : {
208 : // returns total multiplicity
209 : // in V0A
210 : Float_t mul=0.0;
211 0 : for(Int_t i=32;i<64;i++)
212 0 : mul+= fMultiplicity[i];
213 0 : return mul;
214 : }
215 :
216 : //__________________________________________________________________________
217 : Float_t AliAODVZERO::GetMTotV0C() const
218 : {
219 : // returns total multiplicity
220 : // in V0C
221 : Float_t mul=0.0;
222 0 : for(Int_t i=0;i<32;i++)
223 0 : mul+= fMultiplicity[i];
224 0 : return mul;
225 : }
226 :
227 : //__________________________________________________________________________
228 : Float_t AliAODVZERO::GetMRingV0A(Int_t ring) const
229 : {
230 : // returns multiplicity in a
231 : // given ring of V0A
232 0 : if (OutOfRange(ring, "AliAODVZERO:::GetMRingV0A",4)) return -1;
233 : Float_t mul =0.0;
234 :
235 0 : if (ring == 0) for(Int_t i=32;i<40;i++) mul += fMultiplicity[i];
236 0 : if (ring == 1) for(Int_t i=40;i<48;i++) mul += fMultiplicity[i];
237 0 : if (ring == 2) for(Int_t i=48;i<56;i++) mul += fMultiplicity[i];
238 0 : if (ring == 3) for(Int_t i=56;i<64;i++) mul += fMultiplicity[i];
239 : return mul ;
240 0 : }
241 :
242 : //__________________________________________________________________________
243 : Float_t AliAODVZERO::GetMRingV0C(Int_t ring) const
244 : {
245 : // returns multiplicity in a
246 : // given ring of V0C
247 0 : if (OutOfRange(ring, "AliAODVZERO:::GetMRingV0C",4)) return -1;
248 : Float_t mul =0.0;
249 :
250 0 : if (ring == 0) for(Int_t i=0;i<8;i++) mul += fMultiplicity[i];
251 0 : if (ring == 1) for(Int_t i=8;i<16;i++) mul += fMultiplicity[i];
252 0 : if (ring == 2) for(Int_t i=16;i<24;i++) mul += fMultiplicity[i];
253 0 : if (ring == 3) for(Int_t i=24;i<32;i++) mul += fMultiplicity[i];
254 : return mul ;
255 0 : }
256 :
257 : //__________________________________________________________________________
258 : Float_t AliAODVZERO::GetMultiplicity(Int_t i) const
259 :
260 : {
261 : // returns multiplicity in a
262 : // given cell of V0
263 0 : if (OutOfRange(i, "AliAODVZERO::GetMultiplicity:",64)) return -1;
264 0 : return fMultiplicity[i];
265 0 : }
266 :
267 : //__________________________________________________________________________
268 : Float_t AliAODVZERO::GetMultiplicityV0A(Int_t i) const
269 :
270 : {
271 : // returns multiplicity in a
272 : // given cell of V0A
273 0 : if (OutOfRange(i, "AliAODVZERO::GetMultiplicityV0A:",32)) return -1;
274 0 : return fMultiplicity[32+i];
275 0 : }
276 :
277 : //__________________________________________________________________________
278 : Float_t AliAODVZERO::GetMultiplicityV0C(Int_t i) const
279 :
280 : {
281 : // returns multiplicity in a
282 : // given cell of V0C
283 0 : if (OutOfRange(i, "AliAODVZERO::GetMultiplicityV0C:",32)) return -1;
284 0 : return fMultiplicity[i];
285 0 : }
286 :
287 : //__________________________________________________________________________
288 : Bool_t AliAODVZERO::BBTriggerV0A(Int_t i) const
289 : {
290 : // returns offline beam-beam flags in V0A
291 : // one bit per cell
292 0 : if (OutOfRange(i, "AliAODVZERO:::BBTriggerV0A",32)) return kFALSE;
293 : UInt_t test = 1;
294 0 : return ( fBBtriggerV0A & (test << i) ? kTRUE : kFALSE );
295 0 : }
296 :
297 : //__________________________________________________________________________
298 : Bool_t AliAODVZERO::BGTriggerV0A(Int_t i) const
299 : {
300 : // returns offline beam-gas flags in V0A
301 : // one bit per cell
302 0 : if (OutOfRange(i, "AliAODVZERO:::BGTriggerV0A",32)) return kFALSE;
303 : UInt_t test = 1;
304 0 : return ( fBGtriggerV0A & (test << i) ? kTRUE : kFALSE );
305 0 : }
306 :
307 : //__________________________________________________________________________
308 : Bool_t AliAODVZERO::BBTriggerV0C(Int_t i) const
309 : {
310 : // returns offline beam-beam flags in V0C
311 : // one bit per cell
312 0 : if (OutOfRange(i, "AliAODVZERO:::BBTriggerV0C",32)) return kFALSE;
313 : UInt_t test = 1;
314 0 : return ( fBBtriggerV0C & (test << i) ? kTRUE : kFALSE );
315 0 : }
316 :
317 : //__________________________________________________________________________
318 : Bool_t AliAODVZERO::BGTriggerV0C(Int_t i) const
319 : {
320 : // returns offline beam-gasflags in V0C
321 : // one bit per cell
322 0 : if (OutOfRange(i, "AliAODVZERO:::BGTriggerV0C",32)) return kFALSE;
323 : UInt_t test = 1;
324 0 : return ( fBGtriggerV0C & (test << i) ? kTRUE : kFALSE );
325 0 : }
326 :
327 : //__________________________________________________________________________
328 : Bool_t AliAODVZERO::GetBBFlag(Int_t i) const
329 :
330 : {
331 : // returns online beam-beam flag in V0
332 : // one boolean per cell
333 0 : if (OutOfRange(i, "AliAODVZERO::GetBBFlag:",64)) return kFALSE;
334 0 : return fBBFlag[i];
335 0 : }
336 :
337 : //__________________________________________________________________________
338 : Bool_t AliAODVZERO::GetBGFlag(Int_t i) const
339 :
340 : {
341 : // returns online beam-gas flag in V0
342 : // one boolean per cell
343 0 : if (OutOfRange(i, "AliAODVZERO::GetBGFlag:",64)) return kFALSE;
344 0 : return fBGFlag[i];
345 0 : }
|
