]>
Commit | Line | Data |
---|---|---|
2bb2434e | 1 | /************************************************************************** |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
f61c548e | 4 | * Author: Martin Wilde, Friederike Bock, Daniel Lohner, Svein Lindal * |
5 | * based on previous version by Kenneth Aamodt and Ana Marin * | |
2bb2434e | 6 | * Version 1.0 * |
7 | * * | |
8 | * Permission to use, copy, modify and distribute this software and its * | |
9 | * documentation strictly for non-commercial purposes is hereby granted * | |
10 | * without fee, provided that the above copyright notice appears in all * | |
11 | * copies and that both the copyright notice and this permission notice * | |
12 | * appear in the supporting documentation. The authors make no claims * | |
13 | * about the suitability of this software for any purpose. It is * | |
14 | * provided "as is" without express or implied warranty. * | |
15 | **************************************************************************/ | |
16 | ||
17 | //////////////////////////////////////////////// | |
18 | //--------------------------------------------- | |
19 | // Class for handling of background calculation | |
20 | //--------------------------------------------- | |
21 | //////////////////////////////////////////////// | |
22 | ||
23 | #include "AliGammaConversionAODBGHandler.h" | |
24 | #include "AliKFParticle.h" | |
25 | #include "AliAODConversionPhoton.h" | |
26 | #include "AliAODConversionMother.h" | |
2bb2434e | 27 | |
28 | using namespace std; | |
29 | ||
30 | ClassImp(AliGammaConversionAODBGHandler) | |
31 | ||
f61c548e | 32 | //_____________________________________________________________________________________________________________________________ |
2bb2434e | 33 | AliGammaConversionAODBGHandler::AliGammaConversionAODBGHandler() : |
f61c548e | 34 | TObject(), |
35 | fNEvents(10), | |
36 | fBGEventCounter(NULL), | |
37 | fBGEventENegCounter(NULL), | |
38 | fBGEventMesonCounter(NULL), | |
39 | fBGProbability(NULL), | |
40 | fBGEventVertex(NULL), | |
41 | fNBinsZ(0), | |
42 | fNBinsMultiplicity(0), | |
43 | fBinLimitsArrayZ(NULL), | |
44 | fBinLimitsArrayMultiplicity(NULL), | |
45 | fBGEvents(), | |
46 | fBGEventsENeg(), | |
47 | fBGEventsMeson() | |
2bb2434e | 48 | { |
f61c548e | 49 | // constructor |
2bb2434e | 50 | } |
51 | ||
f61c548e | 52 | //_____________________________________________________________________________________________________________________________ |
2bb2434e | 53 | AliGammaConversionAODBGHandler::AliGammaConversionAODBGHandler(UInt_t binsZ,UInt_t binsMultiplicity,UInt_t nEvents) : |
f61c548e | 54 | TObject(), |
55 | fNEvents(nEvents), | |
56 | fBGEventCounter(NULL), | |
57 | fBGEventENegCounter(NULL), | |
58 | fBGEventMesonCounter(NULL), | |
59 | fBGProbability(NULL), | |
60 | fBGEventVertex(NULL), | |
61 | fNBinsZ(binsZ), | |
62 | fNBinsMultiplicity(binsMultiplicity), | |
63 | fBinLimitsArrayZ(NULL), | |
64 | fBinLimitsArrayMultiplicity(NULL), | |
65 | fBGEvents(binsZ,AliGammaConversionMultipicityVector(binsMultiplicity,AliGammaConversionBGEventVector(nEvents))), | |
66 | fBGEventsENeg(binsZ,AliGammaConversionMultipicityVector(binsMultiplicity,AliGammaConversionBGEventVector(nEvents))), | |
67 | fBGEventsMeson(binsZ,AliGammaConversionMotherMultipicityVector(binsMultiplicity,AliGammaConversionMotherBGEventVector(nEvents))) | |
2bb2434e | 68 | { |
f61c548e | 69 | // constructor |
2bb2434e | 70 | } |
71 | ||
11c1e680 | 72 | |
f61c548e | 73 | //_____________________________________________________________________________________________________________________________ |
cfd87ccd | 74 | AliGammaConversionAODBGHandler::AliGammaConversionAODBGHandler(UInt_t collisionSystem, UInt_t centMin, UInt_t centMax, |
75 | UInt_t nEvents, Bool_t useTrackMult, UInt_t mode, UInt_t binsZ, UInt_t binsMultiplicity) : | |
f61c548e | 76 | TObject(), |
77 | fNEvents(nEvents), | |
78 | fBGEventCounter(NULL), | |
79 | fBGEventENegCounter(NULL), | |
80 | fBGEventMesonCounter(NULL), | |
81 | fBGProbability(NULL), | |
82 | fBGEventVertex(NULL), | |
cfd87ccd | 83 | fNBinsZ(binsZ), |
84 | fNBinsMultiplicity(binsMultiplicity), | |
f61c548e | 85 | fBinLimitsArrayZ(NULL), |
86 | fBinLimitsArrayMultiplicity(NULL), | |
cfd87ccd | 87 | fBGEvents(binsZ,AliGammaConversionMultipicityVector(binsMultiplicity,AliGammaConversionBGEventVector(nEvents))), |
88 | fBGEventsENeg(binsZ,AliGammaConversionMultipicityVector(binsMultiplicity,AliGammaConversionBGEventVector(nEvents))), | |
89 | fBGEventsMeson(binsZ,AliGammaConversionMotherMultipicityVector(binsMultiplicity,AliGammaConversionMotherBGEventVector(nEvents))) | |
11c1e680 | 90 | { |
f61c548e | 91 | // constructor |
cfd87ccd | 92 | if (fNBinsZ>8)fNBinsZ = 8; |
f61c548e | 93 | |
cfd87ccd | 94 | if (mode == 0 || mode == 1){ |
95 | if (fNBinsMultiplicity>5)fNBinsMultiplicity = 5; | |
96 | } else if (mode == 2 || mode == 3 || mode == 4 || mode == 5){ | |
97 | if (useTrackMult){ | |
98 | if (fNBinsMultiplicity>5)fNBinsMultiplicity = 5; | |
99 | } else { | |
100 | if (fNBinsMultiplicity>7)fNBinsMultiplicity = 7; | |
101 | } | |
102 | } else { | |
103 | if (fNBinsMultiplicity>5)fNBinsMultiplicity = 5; | |
104 | } | |
105 | // Initializing z vertex bins | |
106 | fBinLimitsArrayZ= new Double_t[fNBinsZ] ; | |
f61c548e | 107 | if(collisionSystem > 0 && collisionSystem < 8){ // PbPb |
cfd87ccd | 108 | Double_t fBinLimitsArrayZPbPb[8] = {-50, -5.5, -2.9, -0.65, |
109 | 1.45, 3.65, 6.15, 50}; | |
110 | for (Int_t i = 0; i < fNBinsZ; i++){ | |
111 | fBinLimitsArrayZ[i] = fBinLimitsArrayZPbPb[i]; | |
112 | } | |
113 | } else if(collisionSystem == 0){ // pp | |
114 | Double_t fBinLimitsArrayZpp[8] = {-50, -3.375, -1.605, -0.225, | |
115 | 1.065, 2.445, 4.245, 50}; | |
116 | for (Int_t i = 0; i < fNBinsZ; i++){ | |
117 | fBinLimitsArrayZ[i] = fBinLimitsArrayZpp[i]; | |
118 | } | |
119 | } else { // pPb | |
120 | Double_t fBinLimitsArrayZpPb[8] = {-50, -5.85, -3.35, -1.15, | |
121 | 0.85, 2.95, 5.55, 50}; | |
122 | for (Int_t i = 0; i < fNBinsZ; i++){ | |
123 | fBinLimitsArrayZ[i] = fBinLimitsArrayZpPb[i]; | |
124 | } | |
f61c548e | 125 | } |
11c1e680 | 126 | |
cfd87ccd | 127 | // Initializing multiplicity bins |
128 | fBinLimitsArrayMultiplicity= new Double_t[fNBinsMultiplicity]; | |
129 | if(useTrackMult){ // multiplicity binning based on number of good global tracks | |
130 | // default pp values | |
131 | Double_t fBinLimitsArrayMultiplicitypp[5] = {0., 8.5, 16.5, 27.5, 200.}; | |
132 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
133 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicitypp[i]; | |
134 | } | |
135 | if(collisionSystem > 0 && collisionSystem < 8){ // PbPb values | |
136 | if(centMin == 0 && centMax == 5){ // 0-5% central | |
137 | Double_t fBinLimitsArrayMultiplicityPbPb0005[5] = {0., 1540., 1665., 1780., 5000}; | |
138 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
139 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0005[i]; | |
140 | } | |
141 | } else if(centMin == 0 && centMax == 10){ // 0-10% central | |
142 | Double_t fBinLimitsArrayMultiplicityPbPb0010[5] = {0., 1360., 1520., 1685., 5000}; | |
143 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
144 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0010[i]; | |
145 | } | |
146 | } else if(centMin == 0 && centMax == 20){ // 0-20% central | |
147 | Double_t fBinLimitsArrayMultiplicityPbPb0020[5] = {0., 1110., 1360., 1600., 5000}; | |
148 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
149 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0020[i]; | |
150 | } | |
151 | } else if(centMin == 0 && centMax == 80){ // 0-80% central | |
152 | Double_t fBinLimitsArrayMultiplicityPbPb0080[5] = {0., 890., 1240., 1540., 5000}; | |
153 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
154 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0080[i]; | |
155 | } | |
156 | } else if(centMin == 5 && centMax == 10){ // 5-10% central | |
157 | Double_t fBinLimitsArrayMultiplicityPbPb0510[5] = {0., 1250., 1345., 1445., 5000}; | |
158 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
159 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0510[i]; | |
160 | } | |
161 | } else if(centMin == 10 && centMax == 20){ // 10-20% central | |
162 | Double_t fBinLimitsArrayMultiplicityPbPb1020[5] = {0., 915., 1020., 1130., 5000}; | |
163 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
164 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb1020[i]; | |
165 | } | |
166 | } else if(centMin == 20 && centMax == 40){ // 20-40% central | |
167 | Double_t fBinLimitsArrayMultiplicityPbPb2040[5] = {0., 510., 625., 730., 5000}; | |
168 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
169 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb2040[i]; | |
170 | } | |
171 | } else if(centMin == 40 && centMax == 80){ // 40-80% central | |
172 | Double_t fBinLimitsArrayMultiplicityPbPb4080[5] = {0., 185., 250., 300., 5000}; | |
173 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
174 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb4080[i]; | |
175 | } | |
176 | } else if(centMin == 60 && centMax == 80){ // 60-80% central | |
177 | Double_t fBinLimitsArrayMultiplicityPbPb6080[5] = {0., 55., 80., 100., 5000}; | |
178 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
179 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb6080[i]; | |
180 | } | |
181 | } else { // all other centrality classes | |
182 | Double_t fBinLimitsArrayMultiplicityPbPb[5] = {0., 510., 625., 730., 5000}; | |
183 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
184 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb[i]; | |
185 | } | |
f61c548e | 186 | } |
cfd87ccd | 187 | } else if(collisionSystem == 8 || collisionSystem == 9){ // pPb |
188 | Double_t fBinLimitsArrayMultiplicitypPb[5] = {0., 7.5, 16.5, 29.5, 500}; | |
189 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
190 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicitypPb[i]; | |
191 | } | |
192 | if(centMin == 0 && centMax == 20){ // pPb 0-20 % | |
193 | Double_t fBinLimitsArrayMultiplicitypPb0020[5] = {0., 31.5, 40.5, 50.5, 500}; | |
194 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
195 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicitypPb0020[i]; | |
196 | } | |
f61c548e | 197 | } else if(centMin == 20 && centMax == 40){ |
cfd87ccd | 198 | Double_t fBinLimitsArrayMultiplicitypPb2040[5] = {0., 19.5, 25.5, 32.5, 500}; |
199 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
200 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicitypPb2040[i]; | |
201 | } | |
f61c548e | 202 | } else if(centMin == 40 && centMax == 60){ |
cfd87ccd | 203 | Double_t fBinLimitsArrayMultiplicitypPb4060[5] = {0., 12.5, 16.5, 22.5, 500}; |
204 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
205 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicitypPb4060[i]; | |
206 | } | |
f61c548e | 207 | } else if(centMin == 60 && centMax == 80){ |
cfd87ccd | 208 | Double_t fBinLimitsArrayMultiplicitypPb6080[5] = {0., 5.5, 9.5, 13.5, 500}; |
209 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
210 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicitypPb6080[i]; | |
211 | } | |
f61c548e | 212 | } else if(centMin == 60 && centMax == 100){ |
cfd87ccd | 213 | Double_t fBinLimitsArrayMultiplicitypPb60100[5] = {0., 2.5, 6.5, 11.5, 500}; |
214 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
215 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicitypPb60100[i]; | |
216 | } | |
f61c548e | 217 | } |
218 | } | |
cfd87ccd | 219 | } else{ // Initializing Multiplicity binning with photon Mult |
220 | if (mode == 0 || mode == 1) { // settings for Conv-Conv && Conv-Dalitz | |
221 | // pp & pPb defaults | |
222 | Double_t fBinLimitsArrayMultiplicitypp[5] = {2., 3., 4., 5., 9999.}; | |
223 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
224 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicitypp[i]; | |
225 | } | |
226 | if(collisionSystem > 0 && collisionSystem < 8){ // settings PbPb | |
227 | if(centMin == 0 && centMax == 5){ // 0-5% | |
228 | Double_t fBinLimitsArrayMultiplicityPbPb0005[5] = {0., 27., 31., 36., 100.}; | |
229 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
230 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0005[i]; | |
231 | } | |
232 | } else if(centMin == 0 && centMax == 10){ // 0-10% | |
233 | Double_t fBinLimitsArrayMultiplicityPbPb0010[5] = {0., 25., 30., 36., 100.}; | |
234 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
235 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0010[i]; | |
236 | } | |
237 | } else if(centMin == 0 && centMax == 20){ // 0-20% | |
238 | Double_t fBinLimitsArrayMultiplicityPbPb0020[5] = {0., 22., 27., 33., 100.}; | |
239 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
240 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0020[i]; | |
241 | } | |
242 | } else if(centMin == 0 && centMax == 80){ // 0-80% | |
243 | Double_t fBinLimitsArrayMultiplicityPbPb0080[5] = {0., 18., 25., 32., 100.}; | |
244 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
245 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0080[i]; | |
246 | } | |
247 | } else if(centMin == 5 && centMax == 10){ // 5-10% | |
248 | Double_t fBinLimitsArrayMultiplicityPbPb0510[5] = {0., 23., 27., 32., 100.}; | |
249 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
250 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb0510[i]; | |
251 | } | |
252 | } else if(centMin == 10 && centMax == 20){ //10-20% | |
253 | Double_t fBinLimitsArrayMultiplicityPbPb1020[5] = {0., 18., 22., 27., 100.}; | |
254 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
255 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb1020[i]; | |
256 | } | |
257 | } else if(centMin == 20 && centMax == 40){ // 20-40% | |
258 | Double_t fBinLimitsArrayMultiplicityPbPb2040[5] = {0., 11., 14., 18., 100.}; | |
259 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
260 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb2040[i]; | |
261 | } | |
262 | } else if(centMin == 40 && centMax == 80){ // 40-80% | |
263 | Double_t fBinLimitsArrayMultiplicityPbPb4080[5] = {0., 5., 7., 11., 100.}; | |
264 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
265 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb4080[i]; | |
266 | } | |
267 | } else if(centMin == 60 && centMax == 80){ // 60-80% | |
268 | Double_t fBinLimitsArrayMultiplicityPbPb6080[5] = {0., 2., 3., 5., 100.}; | |
269 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
270 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb6080[i]; | |
271 | } | |
272 | } else{ // default PbPb | |
273 | Double_t fBinLimitsArrayMultiplicityPbPb[5] = {0., 11., 14., 18., 100.}; | |
274 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
275 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicityPbPb[i]; | |
276 | } | |
277 | } | |
f61c548e | 278 | } |
cfd87ccd | 279 | } else if (mode == 2 || mode == 3 || mode == 4 || mode == 5){ // setting for EMCAL-Conv, PHOS-Conv, EMCAL-EMCAL, PHOS-PHOS |
280 | Double_t fBinLimitsArrayMultiplicitypp[7] = {0., 2., 3., 4., 8., 15., 9999.}; | |
281 | for (Int_t i = 0; i < fNBinsMultiplicity; i++){ | |
282 | fBinLimitsArrayMultiplicity[i] = fBinLimitsArrayMultiplicitypp[i]; | |
283 | } | |
284 | } | |
285 | } | |
f61c548e | 286 | |
287 | Initialize(fBinLimitsArrayZ,fBinLimitsArrayMultiplicity); | |
11c1e680 | 288 | } |
289 | ||
f61c548e | 290 | //_____________________________________________________________________________________________________________________________ |
2bb2434e | 291 | AliGammaConversionAODBGHandler::AliGammaConversionAODBGHandler(const AliGammaConversionAODBGHandler & original) : |
f61c548e | 292 | TObject(original), |
293 | fNEvents(original.fNEvents), | |
294 | fBGEventCounter(original.fBGEventCounter), | |
295 | fBGEventENegCounter(original.fBGEventENegCounter), | |
296 | fBGEventMesonCounter(original.fBGEventMesonCounter), | |
297 | fBGProbability(original.fBGProbability), | |
298 | fBGEventVertex(original.fBGEventVertex), | |
299 | fNBinsZ(original.fNBinsZ), | |
300 | fNBinsMultiplicity(original.fNBinsMultiplicity), | |
301 | fBinLimitsArrayZ(original.fBinLimitsArrayZ), | |
302 | fBinLimitsArrayMultiplicity(original.fBinLimitsArrayMultiplicity), | |
303 | fBGEvents(original.fBGEvents), | |
304 | fBGEventsENeg(original.fBGEventsENeg), | |
305 | fBGEventsMeson(original.fBGEventsMeson) | |
2bb2434e | 306 | { |
f61c548e | 307 | //copy constructor |
2bb2434e | 308 | } |
309 | ||
f61c548e | 310 | //_____________________________________________________________________________________________________________________________ |
2bb2434e | 311 | AliGammaConversionAODBGHandler & AliGammaConversionAODBGHandler::operator = (const AliGammaConversionAODBGHandler & /*source*/) |
312 | { | |
f61c548e | 313 | // assignment operator |
314 | return *this; | |
2bb2434e | 315 | } |
316 | ||
f61c548e | 317 | //_____________________________________________________________________________________________________________________________ |
2bb2434e | 318 | AliGammaConversionAODBGHandler::~AliGammaConversionAODBGHandler(){ |
319 | ||
f61c548e | 320 | if(fBGEventCounter){ |
321 | for(Int_t z=0;z<fNBinsZ;z++){ | |
322 | delete[] fBGEventCounter[z]; | |
323 | } | |
324 | delete[] fBGEventCounter; | |
325 | fBGEventCounter = NULL; | |
326 | } | |
327 | ||
328 | if(fBGEventVertex){ | |
329 | for(Int_t z=0;z<fNBinsZ;z++){ | |
330 | for(Int_t m=0;m<fNBinsMultiplicity;m++){ | |
331 | delete [] fBGEventVertex[z][m]; | |
332 | } | |
333 | delete [] fBGEventVertex[z]; | |
334 | } | |
335 | delete [] fBGEventVertex; | |
336 | } | |
337 | ||
338 | if(fBGEventENegCounter){ | |
339 | for(Int_t z=0;z<fNBinsZ;z++){ | |
340 | delete[] fBGEventENegCounter[z]; | |
341 | } | |
342 | delete[] fBGEventENegCounter; | |
343 | fBGEventENegCounter = NULL; | |
344 | } | |
345 | ||
346 | if(fBGEventMesonCounter){ | |
347 | for(Int_t z=0;z<fNBinsZ;z++){ | |
348 | delete[] fBGEventMesonCounter[z]; | |
349 | } | |
350 | delete[] fBGEventMesonCounter; | |
351 | fBGEventMesonCounter = NULL; | |
352 | } | |
353 | ||
354 | if(fBinLimitsArrayZ){ | |
355 | delete[] fBinLimitsArrayZ; | |
356 | } | |
357 | ||
358 | if(fBinLimitsArrayMultiplicity){ | |
359 | delete[] fBinLimitsArrayMultiplicity; | |
360 | } | |
2bb2434e | 361 | } |
362 | ||
f61c548e | 363 | //_____________________________________________________________________________________________________________________________ |
2bb2434e | 364 | void AliGammaConversionAODBGHandler::Initialize(Double_t * const zBinLimitsArray, Double_t * const multiplicityBinLimitsArray){ |
365 | // see header file for documantation | |
366 | ||
f61c548e | 367 | if(zBinLimitsArray){ |
368 | fBinLimitsArrayZ = zBinLimitsArray; | |
369 | } | |
370 | else{ | |
371 | //Print warning | |
372 | } | |
373 | ||
374 | if(multiplicityBinLimitsArray){ | |
375 | fBinLimitsArrayMultiplicity = multiplicityBinLimitsArray ; | |
376 | } | |
377 | else{ | |
378 | //Print warning | |
379 | } | |
380 | if(fBGEventCounter == NULL){ | |
381 | fBGEventCounter= new Int_t*[fNBinsZ]; | |
382 | } | |
383 | for(Int_t z=0;z<fNBinsZ;z++){ | |
384 | fBGEventCounter[z]=new Int_t[fNBinsMultiplicity]; | |
385 | } | |
386 | ||
387 | for(Int_t z=0;z<fNBinsZ;z++){ | |
388 | for(Int_t m=0;m<fNBinsMultiplicity;m++){ | |
389 | fBGEventCounter[z][m]=0; | |
390 | } | |
391 | } | |
392 | ||
393 | if(fBGEventMesonCounter == NULL){ | |
394 | fBGEventMesonCounter= new Int_t*[fNBinsZ]; | |
395 | } | |
396 | for(Int_t z=0;z<fNBinsZ;z++){ | |
397 | fBGEventMesonCounter[z]=new Int_t[fNBinsMultiplicity]; | |
398 | } | |
399 | ||
400 | for(Int_t z=0;z<fNBinsZ;z++){ | |
401 | for(Int_t m=0;m<fNBinsMultiplicity;m++){ | |
402 | fBGEventMesonCounter[z][m]=0; | |
403 | } | |
404 | } | |
405 | ||
406 | ||
407 | if(fBGEventVertex == NULL){ | |
408 | fBGEventVertex = new GammaConversionVertex**[fNBinsZ]; | |
409 | } | |
410 | for(Int_t z=0; z < fNBinsZ; z++){ | |
411 | fBGEventVertex[z]= new GammaConversionVertex*[fNBinsMultiplicity]; | |
412 | } | |
413 | for(Int_t z=0;z<fNBinsZ;z++){ | |
414 | for(Int_t m=0;m<fNBinsMultiplicity; m++){ | |
415 | fBGEventVertex[z][m]= new GammaConversionVertex[fNEvents]; | |
416 | } | |
417 | } | |
418 | if( fBGEventENegCounter == NULL){ | |
419 | fBGEventENegCounter = new Int_t*[fNBinsZ]; | |
420 | } | |
421 | ||
422 | for(Int_t z=0; z < fNBinsZ; z++){ | |
423 | fBGEventENegCounter[z] = new Int_t[fNBinsMultiplicity]; | |
424 | } | |
425 | ||
426 | for(Int_t z=0;z<fNBinsZ;z++){ | |
427 | for(Int_t m=0;m<fNBinsMultiplicity; m++){ | |
428 | fBGEventENegCounter[z][m] = 0; | |
429 | } | |
430 | } | |
431 | ||
432 | if(fBGProbability == NULL){ | |
433 | fBGProbability = new Double_t*[fNBinsZ]; | |
434 | } | |
435 | for(Int_t z=0; z < fNBinsZ; z++){ | |
436 | fBGProbability[z] = new Double_t[fNBinsMultiplicity]; | |
437 | } | |
438 | ||
439 | for(Int_t z=0;z<fNBinsZ;z++){ | |
440 | for(Int_t m=0;m<fNBinsMultiplicity; m++){ | |
441 | fBGProbability[z][m] = 0; | |
442 | } | |
443 | } | |
444 | //filling the probability | |
445 | fBGProbability[0][0] = 0.243594; | |
446 | fBGProbability[0][1] = 0.279477; | |
447 | fBGProbability[0][2] = 0.305104; | |
448 | fBGProbability[0][3] = 0.315927; | |
449 | fBGProbability[1][0] = 0.241964; | |
450 | fBGProbability[1][1] = 0.272995; | |
451 | fBGProbability[1][2] = 0.307165; | |
452 | fBGProbability[1][3] = 0.292248; | |
453 | fBGProbability[2][0] = 0.241059; | |
454 | fBGProbability[2][1] = 0.27509; | |
455 | fBGProbability[2][2] = 0.283657; | |
456 | fBGProbability[2][3] = 0.310512; | |
457 | fBGProbability[3][0] = 0.23888; | |
458 | fBGProbability[3][1] = 0.283418; | |
459 | fBGProbability[3][2] = 0.297232; | |
460 | fBGProbability[3][3] = 0.348188; | |
461 | fBGProbability[4][0] = 0.245555; | |
462 | fBGProbability[4][1] = 0.281218; | |
463 | fBGProbability[4][2] = 0.317236; | |
464 | fBGProbability[4][3] = 0.323495; | |
465 | fBGProbability[5][0] = 0.244572; | |
466 | fBGProbability[5][1] = 0.259498; | |
467 | fBGProbability[5][2] = 0.278383; | |
468 | fBGProbability[5][3] = 0.284696; | |
469 | fBGProbability[6][0] = 0.24703; | |
470 | fBGProbability[6][1] = 0.275265; | |
471 | fBGProbability[6][2] = 0.284004; | |
472 | fBGProbability[6][3] = 0.343584; | |
473 | ||
2bb2434e | 474 | } |
475 | ||
f61c548e | 476 | //_____________________________________________________________________________________________________________________________ |
2bb2434e | 477 | Int_t AliGammaConversionAODBGHandler::GetZBinIndex(Double_t zvalue) const{ |
f61c548e | 478 | // see header file for documantation |
479 | if(fNBinsZ<2 || zvalue<=fBinLimitsArrayZ[0]){ | |
480 | return 0; | |
481 | } | |
482 | ||
483 | for(Int_t i=0; i<fNBinsZ-1 ;i++){ | |
484 | if(zvalue >= fBinLimitsArrayZ[i] && zvalue <= fBinLimitsArrayZ[i+1]){ | |
485 | return i; | |
486 | } | |
487 | } | |
488 | return fNBinsZ-1; | |
2bb2434e | 489 | } |
490 | ||
f61c548e | 491 | //_____________________________________________________________________________________________________________________________ |
2bb2434e | 492 | Int_t AliGammaConversionAODBGHandler::GetMultiplicityBinIndex(Int_t multiplicity) const{ |
f61c548e | 493 | // see header file for documantation |
494 | if(fNBinsMultiplicity<2){ | |
495 | return 0; | |
496 | } | |
497 | ||
498 | for(Int_t i=0; i<fNBinsMultiplicity-1 ;i++){ | |
499 | if(multiplicity >= fBinLimitsArrayMultiplicity[i] && multiplicity < fBinLimitsArrayMultiplicity[i+1]){ | |
500 | return i; | |
501 | } | |
502 | } | |
503 | return fNBinsMultiplicity-1; | |
2bb2434e | 504 | } |
505 | ||
f61c548e | 506 | //_____________________________________________________________________________________________________________________________ |
ae4f2cfb | 507 | void AliGammaConversionAODBGHandler::AddEvent(TList* const eventGammas,Double_t xvalue, Double_t yvalue, Double_t zvalue, Int_t multiplicity, Double_t epvalue){ |
508 | ||
f61c548e | 509 | // see header file for documantation |
510 | ||
511 | // cout<<"Entering the AddEvent function"<<endl; | |
2bb2434e | 512 | |
f61c548e | 513 | Int_t z = GetZBinIndex(zvalue); |
514 | Int_t m = GetMultiplicityBinIndex(multiplicity); | |
515 | ||
516 | if(fBGEventCounter[z][m] >= fNEvents){ | |
517 | fBGEventCounter[z][m]=0; | |
518 | } | |
519 | Int_t eventCounter=fBGEventCounter[z][m]; | |
520 | ||
521 | /* | |
522 | if(fBGEventVertex[z][m][eventCounter]){ | |
523 | delete fBGEventVertex[z][m][eventCounter]; | |
524 | } | |
525 | */ | |
526 | fBGEventVertex[z][m][eventCounter].fX = xvalue; | |
527 | fBGEventVertex[z][m][eventCounter].fY = yvalue; | |
528 | fBGEventVertex[z][m][eventCounter].fZ = zvalue; | |
529 | fBGEventVertex[z][m][eventCounter].fEP = epvalue; | |
530 | ||
531 | //first clear the vector | |
532 | // cout<<"Size of vector: "<<fBGEvents[z][m][eventCounter].size()<<endl; | |
533 | // cout<<"Checking the entries: Z="<<z<<", M="<<m<<", eventCounter="<<eventCounter<<endl; | |
534 | ||
535 | // cout<<"The size of this vector is: "<<fBGEvents[z][m][eventCounter].size()<<endl; | |
536 | for(UInt_t d=0;d<fBGEvents[z][m][eventCounter].size();d++){ | |
537 | delete (AliAODConversionPhoton*)(fBGEvents[z][m][eventCounter][d]); | |
538 | } | |
539 | fBGEvents[z][m][eventCounter].clear(); | |
540 | ||
541 | // add the gammas to the vector | |
542 | for(Int_t i=0; i< eventGammas->GetEntries();i++){ | |
543 | // AliKFParticle *t = new AliKFParticle(*(AliKFParticle*)(eventGammas->At(i))); | |
544 | fBGEvents[z][m][eventCounter].push_back(new AliAODConversionPhoton(*(AliAODConversionPhoton*)(eventGammas->At(i)))); | |
545 | } | |
546 | fBGEventCounter[z][m]++; | |
2bb2434e | 547 | } |
2bb2434e | 548 | |
f61c548e | 549 | //_____________________________________________________________________________________________________________________________ |
550 | void AliGammaConversionAODBGHandler::AddMesonEvent(TList* const eventMothers, Double_t xvalue, Double_t yvalue, Double_t zvalue, Int_t multiplicity, Double_t epvalue){ | |
2bb2434e | 551 | |
f61c548e | 552 | // see header file for documantation |
553 | // cout<<"Entering the AddEvent function"<<endl; | |
554 | Int_t z = GetZBinIndex(zvalue); | |
555 | Int_t m = GetMultiplicityBinIndex(multiplicity); | |
2bb2434e | 556 | |
f61c548e | 557 | if(fBGEventMesonCounter[z][m] >= fNEvents){ |
558 | fBGEventMesonCounter[z][m]=0; | |
559 | } | |
560 | Int_t eventCounter=fBGEventMesonCounter[z][m]; | |
561 | ||
562 | fBGEventVertex[z][m][eventCounter].fX = xvalue; | |
563 | fBGEventVertex[z][m][eventCounter].fY = yvalue; | |
564 | fBGEventVertex[z][m][eventCounter].fZ = zvalue; | |
565 | fBGEventVertex[z][m][eventCounter].fEP = epvalue; | |
566 | ||
567 | //first clear the vector | |
568 | for(UInt_t d=0;d<fBGEvents[z][m][eventCounter].size();d++){ | |
569 | delete (AliAODConversionMother*)(fBGEventsMeson[z][m][eventCounter][d]); | |
570 | } | |
571 | fBGEventsMeson[z][m][eventCounter].clear(); | |
572 | ||
573 | // add the gammas to the vector | |
574 | for(Int_t i=0; i< eventMothers->GetEntries();i++){ | |
575 | fBGEventsMeson[z][m][eventCounter].push_back(new AliAODConversionMother(*(AliAODConversionMother*)(eventMothers->At(i)))); | |
576 | } | |
577 | fBGEventMesonCounter[z][m]++; | |
578 | } | |
2bb2434e | 579 | |
2bb2434e | 580 | |
f61c548e | 581 | //_____________________________________________________________________________________________________________________________ |
582 | void AliGammaConversionAODBGHandler::AddElectronEvent(TClonesArray* const eventENeg, Double_t zvalue, Int_t multiplicity){ | |
2bb2434e | 583 | |
f61c548e | 584 | Int_t z = GetZBinIndex(zvalue); |
585 | Int_t m = GetMultiplicityBinIndex(multiplicity); | |
2bb2434e | 586 | |
f61c548e | 587 | if(fBGEventENegCounter[z][m] >= fNEvents){ |
588 | fBGEventENegCounter[z][m]=0; | |
589 | } | |
590 | Int_t eventENegCounter=fBGEventENegCounter[z][m]; | |
591 | ||
592 | //first clear the vector | |
593 | // cout<<"Size of vector: "<<fBGEvents[z][m][eventCounter].size()<<endl; | |
594 | // cout<<"Checking the entries: Z="<<z<<", M="<<m<<", eventCounter="<<eventCounter<<endl; | |
595 | ||
596 | // cout<<"The size of this vector is: "<<fBGEvents[z][m][eventCounter].size()<<endl; | |
597 | for(UInt_t d=0;d<fBGEventsENeg[z][m][eventENegCounter].size();d++){ | |
598 | delete (AliAODConversionPhoton*)(fBGEventsENeg[z][m][eventENegCounter][d]); | |
599 | } | |
2bb2434e | 600 | |
f61c548e | 601 | fBGEventsENeg[z][m][eventENegCounter].clear(); |
2bb2434e | 602 | |
f61c548e | 603 | // add the electron to the vector |
604 | for(Int_t i=0; i< eventENeg->GetEntriesFast();i++){ | |
605 | // AliKFParticle *t = new AliKFParticle(*(AliKFParticle*)(eventGammas->At(i))); | |
606 | fBGEventsENeg[z][m][eventENegCounter].push_back(new AliAODConversionPhoton(*(AliAODConversionPhoton*)(eventENeg->At(i)))); | |
607 | } | |
608 | fBGEventENegCounter[z][m]++; | |
2bb2434e | 609 | } |
f61c548e | 610 | |
611 | //_____________________________________________________________________________________________________________________________ | |
2bb2434e | 612 | AliGammaConversionAODVector* AliGammaConversionAODBGHandler::GetBGGoodV0s(Int_t zbin, Int_t mbin, Int_t event){ |
f61c548e | 613 | //see headerfile for documentation |
614 | return &(fBGEvents[zbin][mbin][event]); | |
2bb2434e | 615 | } |
2bb2434e | 616 | |
f61c548e | 617 | //_____________________________________________________________________________________________________________________________ |
618 | AliGammaConversionMotherAODVector* AliGammaConversionAODBGHandler::GetBGGoodMesons(Int_t zbin, Int_t mbin, Int_t event){ | |
619 | //see headerfile for documentation | |
620 | return &(fBGEventsMeson[zbin][mbin][event]); | |
621 | } | |
2bb2434e | 622 | |
f61c548e | 623 | //_____________________________________________________________________________________________________________________________ |
624 | AliGammaConversionAODVector* AliGammaConversionAODBGHandler::GetBGGoodENeg(Int_t event, Double_t zvalue, Int_t multiplicity){ | |
625 | //see headerfile for documentation | |
626 | Int_t z = GetZBinIndex(zvalue); | |
627 | Int_t m = GetMultiplicityBinIndex(multiplicity); | |
628 | return &(fBGEventsENeg[z][m][event]); | |
2bb2434e | 629 | } |
f61c548e | 630 | |
631 | //_____________________________________________________________________________________________________________________________ | |
2bb2434e | 632 | void AliGammaConversionAODBGHandler::PrintBGArray(){ |
f61c548e | 633 | //see headerfile for documentation |
634 | for(Int_t z=0;z<fNBinsZ;z++){ | |
635 | if(z==2){ | |
636 | cout<<"Getting the data for z bin: "<<z<<endl; | |
637 | for(Int_t multiplicity=0;multiplicity<fNBinsMultiplicity;multiplicity++){ | |
638 | if(multiplicity==2){ | |
639 | cout<<"Getting the data for multiplicity bin: "<<multiplicity<<endl; | |
640 | for(Int_t event=0;event<fNEvents;event++){ | |
641 | if(fBGEvents[z][multiplicity][event].size()>0){ | |
642 | cout<<"Event: "<<event<<" has: "<<fBGEvents[z][multiplicity][event].size()<<endl; | |
643 | } | |
644 | } | |
645 | } | |
646 | } | |
647 | } | |
648 | } | |
2bb2434e | 649 | } |