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