CRAB added
[u/mrichter/AliRoot.git] / HBTAN / AliHBTWeightFctn.cxx
1 #include "AliHBTWeightFctn.h"
2 /* $Id$ */
3 //_________________________________________________________________________
4 //
5 // class 
6 //
7 //This class allows to obtain Q_inv correlation function with weights
8 //calculated by Lednicky's alghorithm.
9 //Numerator is filled with weighted events. Weights are attributed to reconstructed tracks.
10 //Weights are calculated with corresponding simulated particles momenta.
11 //Denominator is filled with mixing unweighted reconstructed tracks.
12 //One needs both pairs 
13 //(simulated and recontructed), thus function is of class AliHBTTwoPairFctn1D.
14 //Author: Ludmila Malinina, JINR (malinina@sunhe.jinr.ru)
15 #include "AliHBTWeightsPID.h"
16
17 //--for test--AliHBTWeightQInvFctn* yyy= new AliHBTWeightQInvFctn();
18
19 ClassImp( AliHBTWeightQInvFctn )
20
21   
22 /****************************************************************/
23 AliHBTWeightQInvFctn::AliHBTWeightQInvFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
24  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
25 {
26 //ctor
27  fWriteNumAndDen = kTRUE;//change default behaviour
28  Rename("wqinvcf","Q_{inv} Weight Correlation Function");
29 }
30 /****************************************************************/
31 void  AliHBTWeightQInvFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
32 {
33   //process particles from same events (fills numerator)
34   trackpair = CheckPair(trackpair);
35   partpair  = CheckPair(partpair);
36   if ( trackpair && partpair)     
37   {
38 //    Double_t weightPID=1.;
39     Double_t weight = 1.0;
40     if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
41          ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
42       {   
43          weight=partpair->GetWeight();
44       }   
45 //    Double_t weight=weightHBT*weightPID;
46     fNumerator->Fill(trackpair->GetQInv(),weight);
47   }
48
49 /****************************************************************/
50
51 void  AliHBTWeightQInvFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
52 {
53   // Fills the denominator using mixed pairs
54   trackpair = CheckPair(trackpair);
55   partpair  = CheckPair(partpair);
56   if ( trackpair && partpair)  
57   {
58      fDenominator->Fill(trackpair->GetQInv());
59   }
60 }
61 /**************************************************************/
62 TH1* AliHBTWeightQInvFctn::GetResult()
63
64 //returns ratio of numerator and denominator                                    
65  return GetRatio(Scale());                                                  
66 }                    
67                                                               
68 /**************************************************************************************/
69 /**************************************************************************************/
70 /**************************************************************************************/
71 /**************************************************************************************/
72
73 ClassImp(AliHBTWeightQOutFctn)
74     
75 AliHBTWeightQOutFctn::AliHBTWeightQOutFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
76  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
77 {
78 //ctor
79  fWriteNumAndDen = kTRUE;//change default behaviour
80  Rename("wqoutcf","Q_{out} Weight Correlation Function");
81 }
82 /****************************************************************/
83 void AliHBTWeightQOutFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
84 {
85   //process particles from same events (fills numerator)  
86   trackpair = CheckPair(trackpair);
87   partpair  = CheckPair(partpair);
88   if ( trackpair && partpair)     
89   {
90 //    Double_t weightPID=1.;
91     Double_t weight = 1.0;
92     if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
93          ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
94       {   
95          weight=partpair->GetWeight();
96       }   
97 //    Double_t weight=weightHBT*weightPID;
98     fNumerator->Fill(trackpair->GetQOutCMSLC(),weight);
99   }
100
101 /****************************************************************/
102
103 void AliHBTWeightQOutFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
104 {
105   //process particles from diff events (fills denominator)
106   trackpair = CheckPair(trackpair);
107   partpair  = CheckPair(partpair);
108   if ( trackpair && partpair)  
109   {
110      fDenominator->Fill(trackpair->GetQOutCMSLC());
111   }
112 }
113 /**************************************************************/
114 TH1* AliHBTWeightQOutFctn::GetResult() 
115                                                                                
116
117 //returns ratio of numerator and denominator                                    
118  return GetRatio(Scale());                                                  
119 }                    
120                                                               
121 /*************************************************************************************/ 
122 /*************************************************************************************/ 
123 /*************************************************************************************/ 
124
125 ClassImp(AliHBTWeightQLongFctn)
126 AliHBTWeightQLongFctn::AliHBTWeightQLongFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
127  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
128 {
129 //ctor
130  fWriteNumAndDen = kTRUE;//change default behaviour
131  Rename("wqlongcf","Q_{long} Weight Correlation Function");
132 }
133 /****************************************************************/
134 void AliHBTWeightQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
135 {
136   //process particles from same events (fills numerator)
137   trackpair = CheckPair(trackpair);
138   partpair  = CheckPair(partpair);
139   if ( trackpair && partpair)     
140   {
141 //    Double_t weightPID=1.;
142     Double_t weight = 1.0;
143     if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
144          ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
145       {   
146          weight=partpair->GetWeight();
147       }   
148 //    Double_t weight=weightHBT*weightPID;
149     fNumerator->Fill(trackpair->GetQLongCMSLC(),weight);
150   }
151
152 /****************************************************************/
153
154 void AliHBTWeightQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
155 {
156   //process particles from diff events (fills denominator)
157   trackpair = CheckPair(trackpair);
158   partpair  = CheckPair(partpair);
159   if ( trackpair && partpair)  
160   {
161      fDenominator->Fill(trackpair->GetQLongCMSLC());
162   }
163 }
164 /**************************************************************/
165 TH1* AliHBTWeightQLongFctn::GetResult() 
166                                                                                
167
168 //returns ratio of numerator and denominator                                    
169  return GetRatio(Scale());                                                  
170 }                    
171                                                               
172 /*************************************************************************************/ 
173 /*************************************************************************************/ 
174 /*************************************************************************************/ 
175
176 ClassImp(AliHBTWeightQSideFctn)
177 /*************************************************************************************/ 
178
179 AliHBTWeightQSideFctn::AliHBTWeightQSideFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
180  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
181 {
182 //ctor
183  fWriteNumAndDen = kTRUE;//change default behaviour
184  Rename("wqsidecf","Q_{side} Weight Correlation Function");
185 }
186 /****************************************************************/
187 void AliHBTWeightQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
188 {
189   //process particles from same events (fills numerator)
190   trackpair = CheckPair(trackpair);
191   partpair  = CheckPair(partpair);
192   if ( trackpair && partpair)     
193   {
194 //    Double_t weightPID=1.;
195     Double_t weight = 1.0;
196     if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
197          ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
198       {   
199          weight=partpair->GetWeight();
200       }   
201 //    Double_t weight=weightHBT*weightPID;
202     fNumerator->Fill(trackpair->GetQSideCMSLC(),weight);
203   }
204
205 /****************************************************************/
206
207 void  AliHBTWeightQSideFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
208 {
209   //process particles from diff events (fills denominator)
210   trackpair = CheckPair(trackpair);
211   partpair  = CheckPair(partpair);
212   if ( trackpair && partpair)  
213   {
214      fDenominator->Fill(trackpair->GetQSideCMSLC());
215   }
216 }
217 /**************************************************************/
218 TH1* AliHBTWeightQSideFctn::GetResult() 
219                                                                                
220
221 //returns ratio of numerator and denominator                                    
222  return GetRatio(Scale());                                                  
223 }                    
224                                                               
225 /*************************************************************************************/ 
226 /*************************************************************************************/ 
227 /*************************************************************************************/ 
228
229 ClassImp(AliHBTWeightTwoKStarFctn)
230 /*************************************************************************************/ 
231 AliHBTWeightTwoKStarFctn::AliHBTWeightTwoKStarFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
232  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
233 {
234 //ctor
235  fWriteNumAndDen = kTRUE;//change default behaviour
236  Rename("wtwokstarcf","2*K^{*} Weight Correlation Function");
237 }
238 /****************************************************************/
239 void AliHBTWeightTwoKStarFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
240 {
241   //process particles from same events (fills numerator)
242   trackpair = CheckPair(trackpair);
243   partpair  = CheckPair(partpair);
244   if ( trackpair && partpair)     
245   {
246 //    Double_t weightPID=1.;
247     Double_t weight = 1.0;
248     if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
249          ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
250       {   
251          weight=partpair->GetWeight();
252       }   
253 //    Double_t weight=weightHBT*weightPID;
254     fNumerator->Fill(2.0*(trackpair->GetKStar()),weight);
255   }
256
257 /****************************************************************/
258
259 void  AliHBTWeightTwoKStarFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
260 {
261   //process particles from diff events (fills denominator)
262   trackpair = CheckPair(trackpair);
263   partpair  = CheckPair(partpair);
264   if ( trackpair && partpair)  
265   {
266      fDenominator->Fill(2.0*(trackpair->GetKStar()));
267   }
268 }
269 /**************************************************************/
270 TH1* AliHBTWeightTwoKStarFctn::GetResult() 
271                                                                                
272
273 //returns ratio of numerator and denominator                                    
274  return GetRatio(Scale());                                                  
275 }                    
276                                                               
277 /*************************************************************************************/ 
278 /*************************************************************************************/ 
279 /*************************************************************************************/ 
280
281 ClassImp(AliHBTWeightQOutQSideFctn)
282 /*************************************************************************************/ 
283     
284 AliHBTWeightQOutQSideFctn::AliHBTWeightQOutQSideFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
285                                                          Int_t nybins, Double_t maxYval, Double_t minYval):
286  AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
287 {
288   //ctor
289  fWriteNumAndDen = kTRUE;//change default behaviour
290  Rename("wqoutqsidecf","Q_{out} Q_{side} Weight Correlation Function 2D");
291 }    
292 /*************************************************************************************/ 
293 void AliHBTWeightQOutQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
294 {
295   //process particles from same events (fills numerator)
296   trackpair = CheckPair(trackpair);
297   partpair  = CheckPair(partpair);
298   if ( trackpair && partpair)     
299   {
300 //    Double_t weightPID=1.;
301     Double_t weight = 1.0;
302     if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
303          ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
304       {   
305          weight=partpair->GetWeight();
306       }   
307 //    Double_t weight=weightHBT*weightPID;
308     fNumerator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQSideCMSLC(),weight);
309   }
310
311 /****************************************************************/
312
313 void AliHBTWeightQOutQSideFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
314 {
315   //process particles from diff events (fills denominator)
316   trackpair = CheckPair(trackpair);
317   partpair  = CheckPair(partpair);
318   if ( trackpair && partpair)  
319   {
320      fDenominator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQSideCMSLC());
321   }
322 }
323 /**************************************************************/
324 TH1* AliHBTWeightQOutQSideFctn::GetResult()
325 {
326   //returns result
327   return GetRatio(Scale());
328 }
329
330 /*************************************************************************************/ 
331 /*************************************************************************************/ 
332 /*************************************************************************************/ 
333
334 ClassImp(AliHBTWeightQOutQLongFctn)
335 /*************************************************************************************/ 
336     
337 AliHBTWeightQOutQLongFctn::AliHBTWeightQOutQLongFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
338                                                          Int_t nybins, Double_t maxYval, Double_t minYval):
339  AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
340 {
341   //ctor
342  fWriteNumAndDen = kTRUE;//change default behaviour
343  Rename("wqoutqlongcf","Q_{out} Q_{long} Weight Correlation Function 2D");
344 }    
345 /*************************************************************************************/ 
346 void AliHBTWeightQOutQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
347 {
348   //process particles from same events (fills numerator)
349   trackpair = CheckPair(trackpair);
350   partpair  = CheckPair(partpair);
351   if ( trackpair && partpair)     
352   {
353 //    Double_t weightPID=1.;
354     Double_t weight = 1.0;
355     if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
356          ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
357       {   
358          weight=partpair->GetWeight();
359       }   
360 //    Double_t weight=weightHBT*weightPID;
361     fNumerator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQLongCMSLC(),weight);
362   }
363
364 /****************************************************************/
365
366 void AliHBTWeightQOutQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
367 {
368   //process particles from diff events (fills denominator)
369   trackpair = CheckPair(trackpair);
370   partpair  = CheckPair(partpair);
371   if ( trackpair && partpair)  
372   {
373      fDenominator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQLongCMSLC());
374   }
375 }
376 /**************************************************************/
377
378 TH1* AliHBTWeightQOutQLongFctn::GetResult()
379 {
380   //returns result
381   return GetRatio(Scale());
382 }
383
384 /*************************************************************************************/ 
385 /*************************************************************************************/ 
386 /*************************************************************************************/ 
387
388 ClassImp(AliHBTWeightQSideQLongFctn)
389 /*************************************************************************************/ 
390     
391 AliHBTWeightQSideQLongFctn::AliHBTWeightQSideQLongFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
392                                                          Int_t nybins, Double_t maxYval, Double_t minYval):
393  AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
394 {
395   //ctor
396  fWriteNumAndDen = kTRUE;//change default behaviour
397  Rename("wqsideqlongcf","Q_{side} Q_{long} Weight Correlation Function 2D");
398 }    
399 /*************************************************************************************/ 
400 void AliHBTWeightQSideQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
401 {
402   //process particles from same events (fills numerator)
403   trackpair = CheckPair(trackpair);
404   partpair  = CheckPair(partpair);
405   if ( trackpair && partpair)     
406   {
407 //    Double_t weightPID=1.;
408     Double_t weight = 1.0;
409     if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
410          ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
411       {   
412          weight=partpair->GetWeight();
413       }   
414 //    Double_t weight=weightHBT*weightPID;
415     fNumerator->Fill(trackpair->GetQSideCMSLC(),trackpair->GetQLongCMSLC(),weight);
416   }
417
418 /****************************************************************/
419
420 void AliHBTWeightQSideQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
421 {
422   //process particles from diff events (fills denominator)
423   trackpair = CheckPair(trackpair);
424   partpair  = CheckPair(partpair);
425   if ( trackpair && partpair)  
426   {
427      fDenominator->Fill(trackpair->GetQSideCMSLC(),trackpair->GetQLongCMSLC());
428   }
429 }
430 /**************************************************************/
431 TH1* AliHBTWeightQSideQLongFctn::GetResult()
432 {
433   //returns result
434   return GetRatio(Scale());
435 }