0991d5de20115522f45ba6f928d8ec9011409811
[u/mrichter/AliRoot.git] / HBTAN / AliHBTLLWeightFctn.cxx
1 #include "AliHBTLLWeightFctn.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 "AliHBTLLWeightsPID.h"
16
17 //--for test--AliHBTLLWeightQInvFctn* yyy= new AliHBTLLWeightQInvFctn();
18
19 ClassImp( AliHBTLLWeightQInvFctn )
20
21   
22 /****************************************************************/
23 AliHBTLLWeightQInvFctn::AliHBTLLWeightQInvFctn(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  AliHBTLLWeightQInvFctn::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 weightHBT=partpair->GetLLWeight();
40     Double_t weight=weightHBT*weightPID;
41     if(TMath::Abs(weight)<=10.)fNumerator->Fill(trackpair->GetQInv(),weight);
42   }
43
44 /****************************************************************/
45
46 void  AliHBTLLWeightQInvFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
47 {
48   // Fills the denominator using mixed pairs
49   trackpair = CheckPair(trackpair);
50   partpair  = CheckPair(partpair);
51   if ( trackpair && partpair)  
52   {
53      fDenominator->Fill(trackpair->GetQInv());
54   }
55 }
56 /**************************************************************/
57 TH1* AliHBTLLWeightQInvFctn::GetResult()
58
59 //returns ratio of numerator and denominator                                    
60  return GetRatio(Scale());                                                  
61 }                    
62                                                               
63 /**************************************************************************************/
64 /**************************************************************************************/
65 /**************************************************************************************/
66 /**************************************************************************************/
67
68 ClassImp(AliHBTLLWeightQOutFctn)
69     
70 AliHBTLLWeightQOutFctn::AliHBTLLWeightQOutFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
71  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
72 {
73 //ctor
74  fWriteNumAndDen = kTRUE;//change default behaviour
75  Rename("wqoutcf","Q_{out} Weight Correlation Function");
76 }
77 /****************************************************************/
78 void AliHBTLLWeightQOutFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
79 {
80   //process particles from same events (fills numerator)  
81   trackpair = CheckPair(trackpair);
82   partpair  = CheckPair(partpair);
83   if ( trackpair && partpair)     
84   {
85     Double_t weightPID=1.;
86     Double_t weightHBT=partpair->GetLLWeight();
87     Double_t weight=weightHBT*weightPID;
88     if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQOutCMSLC(),weight);
89   }
90
91 /****************************************************************/
92
93 void AliHBTLLWeightQOutFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
94 {
95   //process particles from diff events (fills denominator)
96   trackpair = CheckPair(trackpair);
97   partpair  = CheckPair(partpair);
98   if ( trackpair && partpair)  
99   {
100      fDenominator->Fill(trackpair->GetQOutCMSLC());
101   }
102 }
103 /**************************************************************/
104 TH1* AliHBTLLWeightQOutFctn::GetResult() 
105                                                                                
106
107 //returns ratio of numerator and denominator                                    
108  return GetRatio(Scale());                                                  
109 }                    
110                                                               
111 /*************************************************************************************/ 
112 /*************************************************************************************/ 
113 /*************************************************************************************/ 
114
115 ClassImp(AliHBTLLWeightQLongFctn)
116 AliHBTLLWeightQLongFctn::AliHBTLLWeightQLongFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
117  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
118 {
119 //ctor
120  fWriteNumAndDen = kTRUE;//change default behaviour
121  Rename("wqlongcf","Q_{long} Weight Correlation Function");
122 }
123 /****************************************************************/
124 void AliHBTLLWeightQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
125 {
126   //process particles from same events (fills numerator)
127   trackpair = CheckPair(trackpair);
128   partpair  = CheckPair(partpair);
129   if ( trackpair && partpair)     
130   {
131     Double_t weightPID=1.;
132     Double_t weightHBT=partpair->GetLLWeight();
133     Double_t weight=weightHBT*weightPID;
134     if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQLongCMSLC(),weight);
135   }
136
137 /****************************************************************/
138
139 void AliHBTLLWeightQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
140 {
141   //process particles from diff events (fills denominator)
142   trackpair = CheckPair(trackpair);
143   partpair  = CheckPair(partpair);
144   if ( trackpair && partpair)  
145   {
146      fDenominator->Fill(trackpair->GetQLongCMSLC());
147   }
148 }
149 /**************************************************************/
150 TH1* AliHBTLLWeightQLongFctn::GetResult() 
151                                                                                
152
153 //returns ratio of numerator and denominator                                    
154  return GetRatio(Scale());                                                  
155 }                    
156                                                               
157 /*************************************************************************************/ 
158 /*************************************************************************************/ 
159 /*************************************************************************************/ 
160
161 ClassImp(AliHBTLLWeightQSideFctn)
162 /*************************************************************************************/ 
163
164 AliHBTLLWeightQSideFctn::AliHBTLLWeightQSideFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
165  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
166 {
167 //ctor
168  fWriteNumAndDen = kTRUE;//change default behaviour
169  Rename("wqsidecf","Q_{side} Weight Correlation Function");
170 }
171 /****************************************************************/
172 void AliHBTLLWeightQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
173 {
174   //process particles from same events (fills numerator)
175   trackpair = CheckPair(trackpair);
176   partpair  = CheckPair(partpair);
177   if ( trackpair && partpair)     
178   {
179     Double_t weightPID=1.;
180     Double_t weightHBT=partpair->GetLLWeight();
181     Double_t weight=weightHBT*weightPID;
182     if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQSideCMSLC(),weight);
183   }
184
185 /****************************************************************/
186
187 void  AliHBTLLWeightQSideFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
188 {
189   //process particles from diff events (fills denominator)
190   trackpair = CheckPair(trackpair);
191   partpair  = CheckPair(partpair);
192   if ( trackpair && partpair)  
193   {
194      fDenominator->Fill(trackpair->GetQSideCMSLC());
195   }
196 }
197 /**************************************************************/
198 TH1* AliHBTLLWeightQSideFctn::GetResult() 
199                                                                                
200
201 //returns ratio of numerator and denominator                                    
202  return GetRatio(Scale());                                                  
203 }                    
204                                                               
205 /*************************************************************************************/ 
206 /*************************************************************************************/ 
207 /*************************************************************************************/ 
208
209 ClassImp(AliHBTLLWeightTwoKStarFctn)
210 /*************************************************************************************/ 
211 AliHBTLLWeightTwoKStarFctn::AliHBTLLWeightTwoKStarFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
212  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
213 {
214 //ctor
215  fWriteNumAndDen = kTRUE;//change default behaviour
216  Rename("wtwokstarcf","2*K^{*} Weight Correlation Function");
217 }
218 /****************************************************************/
219 void AliHBTLLWeightTwoKStarFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
220 {
221   //process particles from same events (fills numerator)
222   trackpair = CheckPair(trackpair);
223   partpair  = CheckPair(partpair);
224   if ( trackpair && partpair)     
225   {
226     Double_t weightPID=1.;
227     Double_t weightHBT=partpair->GetLLWeight();
228     Double_t weight=weightHBT*weightPID;
229     if(TMath::Abs(weight)<=10.) fNumerator->Fill(2.0*(trackpair->GetKStar()),weight);
230   }
231
232 /****************************************************************/
233
234 void  AliHBTLLWeightTwoKStarFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
235 {
236   //process particles from diff events (fills denominator)
237   trackpair = CheckPair(trackpair);
238   partpair  = CheckPair(partpair);
239   if ( trackpair && partpair)  
240   {
241      fDenominator->Fill(2.0*(trackpair->GetKStar()));
242   }
243 }
244 /**************************************************************/
245 TH1* AliHBTLLWeightTwoKStarFctn::GetResult() 
246                                                                                
247
248 //returns ratio of numerator and denominator                                    
249  return GetRatio(Scale());                                                  
250 }                    
251                                                               
252 /*************************************************************************************/ 
253 /*************************************************************************************/ 
254 /*************************************************************************************/ 
255
256 ClassImp(AliHBTLLWeightQOutQSideFctn)
257 /*************************************************************************************/ 
258     
259 AliHBTLLWeightQOutQSideFctn::AliHBTLLWeightQOutQSideFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
260                                                          Int_t nybins, Double_t maxYval, Double_t minYval):
261  AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
262 {
263   //ctor
264  fWriteNumAndDen = kTRUE;//change default behaviour
265  Rename("wqoutqsidecf","Q_{out} Q_{side} Weight Correlation Function 2D");
266 }    
267 /*************************************************************************************/ 
268 void AliHBTLLWeightQOutQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
269 {
270   //process particles from same events (fills numerator)
271   trackpair = CheckPair(trackpair);
272   partpair  = CheckPair(partpair);
273   if ( trackpair && partpair)     
274   {
275     Double_t weightPID=1.;
276     Double_t weightHBT=partpair->GetLLWeight();
277     Double_t weight=weightHBT*weightPID;
278     if(TMath::Abs(weight)<=10.) 
279       fNumerator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQSideCMSLC(),weight);
280   }
281
282 /****************************************************************/
283
284 void AliHBTLLWeightQOutQSideFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
285 {
286   //process particles from diff events (fills denominator)
287   trackpair = CheckPair(trackpair);
288   partpair  = CheckPair(partpair);
289   if ( trackpair && partpair)  
290   {
291      fDenominator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQSideCMSLC());
292   }
293 }
294 /**************************************************************/
295 TH1* AliHBTLLWeightQOutQSideFctn::GetResult()
296 {
297   //returns result
298   return GetRatio(Scale());
299 }
300
301 /*************************************************************************************/ 
302 /*************************************************************************************/ 
303 /*************************************************************************************/ 
304
305 ClassImp(AliHBTLLWeightQOutQLongFctn)
306 /*************************************************************************************/ 
307     
308 AliHBTLLWeightQOutQLongFctn::AliHBTLLWeightQOutQLongFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
309                                                          Int_t nybins, Double_t maxYval, Double_t minYval):
310  AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
311 {
312   //ctor
313  fWriteNumAndDen = kTRUE;//change default behaviour
314  Rename("wqoutqlongcf","Q_{out} Q_{long} Weight Correlation Function 2D");
315 }    
316 /*************************************************************************************/ 
317 void AliHBTLLWeightQOutQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
318 {
319   //process particles from same events (fills numerator)
320   trackpair = CheckPair(trackpair);
321   partpair  = CheckPair(partpair);
322   if ( trackpair && partpair)     
323   {
324     Double_t weightPID=1.;
325     Double_t weightHBT=partpair->GetLLWeight();
326     Double_t weight=weightHBT*weightPID;
327     if(TMath::Abs(weight)<=10.) 
328       fNumerator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQLongCMSLC(),weight);
329   }
330
331 /****************************************************************/
332
333 void AliHBTLLWeightQOutQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
334 {
335   //process particles from diff events (fills denominator)
336   trackpair = CheckPair(trackpair);
337   partpair  = CheckPair(partpair);
338   if ( trackpair && partpair)  
339   {
340      fDenominator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQLongCMSLC());
341   }
342 }
343 /**************************************************************/
344
345 TH1* AliHBTLLWeightQOutQLongFctn::GetResult()
346 {
347   //returns result
348   return GetRatio(Scale());
349 }
350
351 /*************************************************************************************/ 
352 /*************************************************************************************/ 
353 /*************************************************************************************/ 
354
355 ClassImp(AliHBTLLWeightQSideQLongFctn)
356 /*************************************************************************************/ 
357     
358 AliHBTLLWeightQSideQLongFctn::AliHBTLLWeightQSideQLongFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
359                                                          Int_t nybins, Double_t maxYval, Double_t minYval):
360  AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
361 {
362   //ctor
363  fWriteNumAndDen = kTRUE;//change default behaviour
364  Rename("wqsideqlongcf","Q_{side} Q_{long} Weight Correlation Function 2D");
365 }    
366 /*************************************************************************************/ 
367 void AliHBTLLWeightQSideQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
368 {
369   //process particles from same events (fills numerator)
370   trackpair = CheckPair(trackpair);
371   partpair  = CheckPair(partpair);
372   if ( trackpair && partpair)     
373   {
374     Double_t weightPID=1.;
375     Double_t weightHBT=partpair->GetLLWeight();
376     Double_t weight=weightHBT*weightPID;
377     if(TMath::Abs(weight)<=10.) 
378       fNumerator->Fill(trackpair->GetQSideCMSLC(),trackpair->GetQLongCMSLC(),weight);
379   }
380
381 /****************************************************************/
382
383 void AliHBTLLWeightQSideQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
384 {
385   //process particles from diff events (fills denominator)
386   trackpair = CheckPair(trackpair);
387   partpair  = CheckPair(partpair);
388   if ( trackpair && partpair)  
389   {
390      fDenominator->Fill(trackpair->GetQSideCMSLC(),trackpair->GetQLongCMSLC());
391   }
392 }
393 /**************************************************************/
394 TH1* AliHBTLLWeightQSideQLongFctn::GetResult()
395 {
396   //returns result
397   return GetRatio(Scale());
398 }