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 AD data
18 : // Author: Michal Broz
19 : // michal.broz@cern.ch
20 : //-------------------------------------------------------------------------
21 :
22 : #include "AliAODAD.h"
23 : #include "AliLog.h"
24 :
25 170 : ClassImp(AliAODAD)
26 :
27 : //__________________________________________________________________________
28 : AliAODAD::AliAODAD()
29 2 : :AliVAD(),
30 2 : fBBtriggerADA(0),
31 2 : fBGtriggerADA(0),
32 2 : fBBtriggerADC(0),
33 2 : fBGtriggerADC(0),
34 2 : fADATime(-1024),
35 2 : fADCTime(-1024),
36 2 : fADADecision(kADInvalid),
37 2 : fADCDecision(kADInvalid),
38 2 : fTriggerChargeA(0),
39 2 : fTriggerChargeC(0),
40 2 : fTriggerBits(0)
41 10 : {
42 : // Default constructor
43 68 : for(Int_t j=0; j<16; j++){
44 32 : fMultiplicity[j] = 0.0;
45 32 : fBBFlag[j]= kFALSE;
46 32 : fBGFlag[j]= kFALSE;
47 1408 : for(Int_t k = 0; k < 21; ++k) fIsBB[j][k] = fIsBG[j][k] = kFALSE;
48 : }
49 4 : }
50 :
51 : //__________________________________________________________________________
52 : AliAODAD::AliAODAD(const AliAODAD &source)
53 0 : :AliVAD(source),
54 0 : fBBtriggerADA(source.fBBtriggerADA),
55 0 : fBGtriggerADA(source.fBGtriggerADA),
56 0 : fBBtriggerADC(source.fBBtriggerADC),
57 0 : fBGtriggerADC(source.fBGtriggerADC),
58 0 : fADATime(source.fADATime),
59 0 : fADCTime(source.fADCTime),
60 0 : fADADecision(source.fADADecision),
61 0 : fADCDecision(source.fADCDecision),
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<16; 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 : AliAODAD::AliAODAD(const AliVAD &source)
80 0 : :AliVAD(source),
81 0 : fBBtriggerADA(0),
82 0 : fBGtriggerADA(0),
83 0 : fBBtriggerADC(0),
84 0 : fBGtriggerADC(0),
85 0 : fADATime(source.GetADATime()),
86 0 : fADCTime(source.GetADCTime()),
87 0 : fADADecision(source.GetADADecision()),
88 0 : fADCDecision(source.GetADCDecision()),
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<16; 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<8; j++) {
105 0 : if (source.BBTriggerADA(j)) fBBtriggerADA |= (1 << j);
106 0 : if (source.BGTriggerADA(j)) fBGtriggerADA |= (1 << j);
107 0 : if (source.BBTriggerADC(j)) fBBtriggerADC |= (1 << j);
108 0 : if (source.BGTriggerADC(j)) fBGtriggerADC |= (1 << j);
109 : }
110 0 : }
111 :
112 : //__________________________________________________________________________
113 : AliAODAD& AliAODAD::operator=(const AliAODAD& source)
114 : {
115 : // Assignment operator
116 : //
117 0 : if(this==&source) return *this;
118 0 : AliVAD::operator=(source);
119 : // Assignment operator
120 0 : fBBtriggerADA=source.fBBtriggerADA;
121 0 : fBGtriggerADA=source.fBGtriggerADA;
122 0 : fBBtriggerADC=source.fBBtriggerADC;
123 0 : fBGtriggerADC=source.fBGtriggerADC;
124 :
125 0 : fADATime = source.fADATime;
126 0 : fADCTime = source.fADCTime;
127 0 : fADADecision = source.fADADecision;
128 0 : fADCDecision = source.fADCDecision;
129 0 : fTriggerChargeA = source.fTriggerChargeA;
130 0 : fTriggerChargeC = source.fTriggerChargeC;
131 0 : fTriggerBits = source.fTriggerBits;
132 :
133 0 : for(Int_t j=0; j<16; 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 : AliAODAD& AliAODAD::operator=(const AliVAD& source)
147 : {
148 : // Assignment operator
149 : // used in esd->aod filter
150 16 : if(this==&source) return *this;
151 8 : AliVAD::operator=(source);
152 :
153 8 : fADATime = source.GetADATime();
154 8 : fADCTime = source.GetADCTime();
155 8 : fADADecision = source.GetADADecision();
156 8 : fADCDecision = source.GetADCDecision();
157 8 : fTriggerChargeA = source.GetTriggerChargeA();
158 8 : fTriggerChargeC = source.GetTriggerChargeC();
159 8 : fTriggerBits = source.GetTriggerBits();
160 :
161 272 : for(Int_t j=0; j<16; j++) {
162 128 : fMultiplicity[j] = source.GetMultiplicity(j);
163 128 : fBBFlag[j] = source.GetBBFlag(j);
164 128 : fBGFlag[j] = source.GetBGFlag(j);
165 5632 : for(Int_t k = 0; k < 21; ++k) {
166 2688 : fIsBB[j][k] = source.GetPFBBFlag(j,k);
167 2688 : fIsBG[j][k] = source.GetPFBGFlag(j,k);
168 : }
169 :
170 : }
171 :
172 8 : fBBtriggerADA = fBGtriggerADA = fBBtriggerADC = fBGtriggerADC = 0;
173 144 : for(Int_t j=0; j<8; j++) {
174 64 : if (source.BBTriggerADA(j)) fBBtriggerADA |= (1 << j);
175 64 : if (source.BGTriggerADA(j)) fBGtriggerADA |= (1 << j);
176 64 : if (source.BBTriggerADC(j)) fBBtriggerADC |= (1 << j);
177 64 : if (source.BGTriggerADC(j)) fBGtriggerADC |= (1 << j);
178 : }
179 :
180 8 : return *this;
181 :
182 8 : }
183 :
184 : //__________________________________________________________________________
185 : Short_t AliAODAD::GetNbPMADA() const
186 : {
187 : // Returns the number of
188 : // fired PM in ADA
189 : Short_t n=0;
190 0 : for(Int_t i=8;i<16;i++)
191 0 : if (fMultiplicity[i]>0) n++;
192 0 : return n;
193 : }
194 :
195 : //__________________________________________________________________________
196 : Short_t AliAODAD::GetNbPMADC() const
197 : {
198 : // Returns the number of
199 : // fired PM in ADC
200 : Short_t n=0;
201 0 : for(Int_t i=0;i<8;i++)
202 0 : if (fMultiplicity[i]>0) n++;
203 0 : return n;
204 : }
205 :
206 : //__________________________________________________________________________
207 : Float_t AliAODAD::GetMTotADA() const
208 : {
209 : // returns total multiplicity
210 : // in ADA
211 : Float_t mul=0.0;
212 0 : for(Int_t i=8;i<16;i++)
213 0 : mul+= fMultiplicity[i];
214 0 : return mul;
215 : }
216 :
217 : //__________________________________________________________________________
218 : Float_t AliAODAD::GetMTotADC() const
219 : {
220 : // returns total multiplicity
221 : // in ADC
222 : Float_t mul=0.0;
223 0 : for(Int_t i=0;i<8;i++)
224 0 : mul+= fMultiplicity[i];
225 0 : return mul;
226 : }
227 :
228 : //__________________________________________________________________________
229 : Float_t AliAODAD::GetMultiplicity(Int_t i) const
230 :
231 : {
232 : // returns multiplicity in a
233 : // given cell of AD
234 0 : if (OutOfRange(i, "AliAODAD::GetMultiplicity:",16)) return -1;
235 0 : return fMultiplicity[i];
236 0 : }
237 :
238 : //__________________________________________________________________________
239 : Float_t AliAODAD::GetMultiplicityADA(Int_t i) const
240 :
241 : {
242 : // returns multiplicity in a
243 : // given cell of ADA
244 0 : if (OutOfRange(i, "AliAODAD::GetMultiplicityADA:",8)) return -1;
245 0 : return fMultiplicity[8+i];
246 0 : }
247 :
248 : //__________________________________________________________________________
249 : Float_t AliAODAD::GetMultiplicityADC(Int_t i) const
250 :
251 : {
252 : // returns multiplicity in a
253 : // given cell of ADC
254 0 : if (OutOfRange(i, "AliAODAD::GetMultiplicityADC:",8)) return -1;
255 0 : return fMultiplicity[i];
256 0 : }
257 :
258 : //__________________________________________________________________________
259 : Bool_t AliAODAD::BBTriggerADA(Int_t i) const
260 : {
261 : // returns offline beam-beam flags in ADA
262 : // one bit per cell
263 0 : if (OutOfRange(i, "AliAODAD:::BBTriggerADA",8)) return kFALSE;
264 : UInt_t test = 1;
265 0 : return ( fBBtriggerADA & (test << i) ? kTRUE : kFALSE );
266 0 : }
267 :
268 : //__________________________________________________________________________
269 : Bool_t AliAODAD::BGTriggerADA(Int_t i) const
270 : {
271 : // returns offline beam-gas flags in ADA
272 : // one bit per cell
273 0 : if (OutOfRange(i, "AliAODAD:::BGTriggerADA",8)) return kFALSE;
274 : UInt_t test = 1;
275 0 : return ( fBGtriggerADA & (test << i) ? kTRUE : kFALSE );
276 0 : }
277 :
278 : //__________________________________________________________________________
279 : Bool_t AliAODAD::BBTriggerADC(Int_t i) const
280 : {
281 : // returns offline beam-beam flags in ADC
282 : // one bit per cell
283 0 : if (OutOfRange(i, "AliAODAD:::BBTriggerADC",8)) return kFALSE;
284 : UInt_t test = 1;
285 0 : return ( fBBtriggerADC & (test << i) ? kTRUE : kFALSE );
286 0 : }
287 :
288 : //__________________________________________________________________________
289 : Bool_t AliAODAD::BGTriggerADC(Int_t i) const
290 : {
291 : // returns offline beam-gasflags in ADC
292 : // one bit per cell
293 0 : if (OutOfRange(i, "AliAODAD:::BGTriggerADC",8)) return kFALSE;
294 : UInt_t test = 1;
295 0 : return ( fBGtriggerADC & (test << i) ? kTRUE : kFALSE );
296 0 : }
297 :
298 : //__________________________________________________________________________
299 : Bool_t AliAODAD::GetBBFlag(Int_t i) const
300 :
301 : {
302 : // returns online beam-beam flag in AD
303 : // one boolean per cell
304 0 : if (OutOfRange(i, "AliAODAD::GetBBFlag:",16)) return kFALSE;
305 0 : return fBBFlag[i];
306 0 : }
307 :
308 : //__________________________________________________________________________
309 : Bool_t AliAODAD::GetBGFlag(Int_t i) const
310 :
311 : {
312 : // returns online beam-gas flag in AD
313 : // one boolean per cell
314 0 : if (OutOfRange(i, "AliAODAD::GetBGFlag:",16)) return kFALSE;
315 0 : return fBGFlag[i];
316 0 : }
|
