Merging correctly the changes with the previous code clean-up
[u/mrichter/AliRoot.git] / HBTAN / AliHBTLLWeightFctn.cxx
1 /* $Id$ */
2
3 //This class allows to obtain Q_inv correlation function with weights
4 //calculated by Lednicky's alghorithm.
5 //Numerator is filled with weighted events. Weights are attributed to reconstructed tracks.
6 //Weights are calculated with corresponding simulated particles momenta.
7 //Denominator is filled with mixing unweighted reconstructed tracks.
8 //One needs both pairs 
9 //(simulated and recontructed), thus function is of class AliHBTTwoPairFctn1D.
10 //Author: Ludmila Malinina, JINR (malinina@sunhe.jinr.ru)
11 #include "AliHBTLLWeightFctn.h"
12 #include "AliHBTLLWeights.h"
13
14 //--for test--AliHBTLLWeightQInvFctn* yyy= new AliHBTLLWeightQInvFctn();
15
16 ClassImp( AliHBTLLWeightQInvFctn )  
17 /****************************************************************/
18 AliHBTLLWeightQInvFctn::AliHBTLLWeightQInvFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
19            AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
20 {
21 //ctor
22 }
23 /****************************************************************/
24 void  AliHBTLLWeightQInvFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
25 {
26 //Processes Particles and tracks Same different even
27   trackpair = CheckPair(trackpair);
28   partpair  = CheckPair(partpair);
29   if ( trackpair && partpair)     
30   {
31     Double_t weightPID=1.;
32     Double_t weightHBT=AliHBTLLWeights::Instance()->GetWeight(partpair);
33     Double_t weight=weightHBT*weightPID;
34     if(TMath::Abs(weight)<=10.)fNumerator->Fill(trackpair->GetQInv(),weight);
35   }
36
37 /****************************************************************/
38
39 void  AliHBTLLWeightQInvFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
40 {
41   // Fills the denominator using mixed pairs
42   trackpair = CheckPair(trackpair);
43   partpair  = CheckPair(partpair);
44   if ( trackpair && partpair)  
45   {
46      fDenominator->Fill(trackpair->GetQInv());
47   }
48 }
49 /**************************************************************/
50 TH1* AliHBTLLWeightQInvFctn::GetResult() 
51                                                                                
52
53 //returns ratio of numerator and denominator                                    
54  return GetRatio(Scale());                                                  
55 }                    
56                                                               
57 /**************************************************************************************/
58 /**************************************************************************************/
59 /**************************************************************************************/
60 /**************************************************************************************/
61
62 ClassImp(AliHBTLLWeightQOutFctn)
63 /****************************************************************/
64 void AliHBTLLWeightQOutFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
65 {
66   trackpair = CheckPair(trackpair);
67   partpair  = CheckPair(partpair);
68   if ( trackpair && partpair)     
69   {
70     Double_t weightPID=1.;
71     Double_t weightHBT=AliHBTLLWeights::Instance()->GetWeight(partpair);
72     Double_t weight=weightHBT*weightPID;
73     if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQOutCMSLC(),weight);
74   }
75
76 /****************************************************************/
77
78 void AliHBTLLWeightQOutFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
79 {
80   trackpair = CheckPair(trackpair);
81   partpair  = CheckPair(partpair);
82   if ( trackpair && partpair)  
83   {
84      fDenominator->Fill(trackpair->GetQOutCMSLC());
85   }
86 }
87 /**************************************************************/
88 TH1* AliHBTLLWeightQOutFctn::GetResult() 
89                                                                                
90
91 //returns ratio of numerator and denominator                                    
92  return GetRatio(Scale());                                                  
93 }                    
94                                                               
95 /*************************************************************************************/ 
96 /*************************************************************************************/ 
97 /*************************************************************************************/ 
98
99 ClassImp(AliHBTLLWeightQLongFctn)
100 /****************************************************************/
101 void  AliHBTLLWeightQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
102 {
103 //Processes Particles and tracks Same different even
104   trackpair = CheckPair(trackpair);
105   partpair  = CheckPair(partpair);
106   if ( trackpair && partpair)     
107   {
108     Double_t weightPID=1.;
109     Double_t weightHBT=AliHBTLLWeights::Instance()->GetWeight(partpair);
110     Double_t weight=weightHBT*weightPID;
111     if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQLongCMSLC(),weight);
112   }
113
114 /****************************************************************/
115
116 void  AliHBTLLWeightQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
117 {
118   trackpair = CheckPair(trackpair);
119   partpair  = CheckPair(partpair);
120   if ( trackpair && partpair)  
121   {
122      fDenominator->Fill(trackpair->GetQLongCMSLC());
123   }
124 }
125 /**************************************************************/
126 TH1* AliHBTLLWeightQLongFctn::GetResult() 
127                                                                                
128
129 //returns ratio of numerator and denominator                                    
130  return GetRatio(Scale());                                                  
131 }                    
132                                                               
133 /*************************************************************************************/ 
134 /*************************************************************************************/ 
135 /*************************************************************************************/ 
136
137 ClassImp(AliHBTLLWeightQSideFctn)
138 /****************************************************************/
139 void  AliHBTLLWeightQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
140 {
141 //Processes Particles and tracks Same different even
142   trackpair = CheckPair(trackpair);
143   partpair  = CheckPair(partpair);
144   if ( trackpair && partpair)     
145   {
146     Double_t weightPID=1.;
147     Double_t weightHBT=AliHBTLLWeights::Instance()->GetWeight(partpair);
148     Double_t weight=weightHBT*weightPID;
149     if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQSideCMSLC(),weight);
150   }
151
152 /****************************************************************/
153
154 void  AliHBTLLWeightQSideFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
155 {
156   trackpair = CheckPair(trackpair);
157   partpair  = CheckPair(partpair);
158   if ( trackpair && partpair)  
159   {
160      fDenominator->Fill(trackpair->GetQSideCMSLC());
161   }
162 }
163 /**************************************************************/
164 TH1* AliHBTLLWeightQSideFctn::GetResult() 
165                                                                                
166
167 //returns ratio of numerator and denominator                                    
168  return GetRatio(Scale());                                                  
169 }                    
170                                                               
171 /*************************************************************************************/ 
172 /*************************************************************************************/ 
173
174 ClassImp(AliHBTLLWeightTwoKStarFctn)
175 /****************************************************************/
176 void  AliHBTLLWeightTwoKStarFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
177 {
178 //Processes Particles and tracks Same different even
179   trackpair = CheckPair(trackpair);
180   partpair  = CheckPair(partpair);
181   if ( trackpair && partpair)     
182   {
183     Double_t weightPID=1.;
184     Double_t weightHBT=AliHBTLLWeights::Instance()->GetWeight(partpair);
185     Double_t weight=weightHBT*weightPID;
186     if(TMath::Abs(weight)<=10.) fNumerator->Fill(2.0*(trackpair->GetKStar()),weight);
187   }
188
189 /****************************************************************/
190
191 void  AliHBTLLWeightTwoKStarFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
192 {
193   trackpair = CheckPair(trackpair);
194   partpair  = CheckPair(partpair);
195   if ( trackpair && partpair)  
196   {
197      fDenominator->Fill(2.0*(trackpair->GetKStar()));
198   }
199 }
200 /**************************************************************/
201 TH1* AliHBTLLWeightTwoKStarFctn::GetResult() 
202                                                                                
203
204 //returns ratio of numerator and denominator                                    
205  return GetRatio(Scale());                                                  
206 }                    
207                                                               
208 /*************************************************************************************/ 
209