Introduction of the Copyright and cvs Log
[u/mrichter/AliRoot.git] / EVGEN / AliDimuCombinator.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, 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 $Log$
18 */
19
20 //
21 //
22 //
23 //
24 #include "AliDimuCombinator.h" 
25 #include "AliRun.h" 
26 #include "TRandom.h" 
27 //
28 ClassImp(AliDimuCombinator)
29 //
30 //                       Iterators
31 // 
32  TParticle* AliDimuCombinator::FirstMuon()
33      {
34          fimuon1=fimin1;
35          fmuon1 = (TParticle*) fPartArray->UncheckedAt(fimuon1);
36          while(Type(fmuon1)!=5 && Type(fmuon1)!=6) {
37              fimuon1++;
38              if (fimuon1 >= fimax1) {fmuon1=0; break;}
39              fmuon1 = (TParticle*) fPartArray->UncheckedAt(fimuon1);
40          }
41          return fmuon1;
42      }
43              
44  TParticle* AliDimuCombinator::FirstMuonSelected()
45      {
46          TParticle * muon=FirstMuon();
47          while(muon!=0 && !Selected(muon)) {muon=NextMuon();}
48          return muon;
49      }
50              
51
52  TParticle* AliDimuCombinator::NextMuon()
53      {
54          fimuon1++;
55          if (fimuon1>=fNParticle) {fmuon1 = 0; return fmuon1;}
56          
57          fmuon1 = (TParticle*) fPartArray->UncheckedAt(fimuon1);
58          while(Type(fmuon1)!=5 && Type(fmuon1)!=6) {
59              fimuon1++;
60              if (fimuon1>=fimax1) {fmuon1 = 0; break;}
61              fmuon1 = (TParticle*) fPartArray->UncheckedAt(fimuon1);
62          }
63          return fmuon1;
64      }
65
66 TParticle* AliDimuCombinator::NextMuonSelected()
67      {
68          TParticle * muon=NextMuon();
69          while(muon !=0 && !Selected(muon)) {muon=NextMuon();}
70          return muon;
71      }
72
73
74  void AliDimuCombinator::FirstPartner()
75      {
76          if (fimin1==fimin2) {
77              fimuon2=fimuon1+1;
78          } else {
79              fimuon2=fimin2;
80          }
81          if (fimuon2 >= fimax2) {fmuon2=0; return;}
82          fmuon2 = (TParticle*) fPartArray->UncheckedAt(fimuon2);
83          while(Type(fmuon2)!=5 && Type(fmuon2)!=6) {
84              fimuon2++;
85              if (fimuon2 >= fimax2) {fmuon2=0; break;}
86              fmuon2 = (TParticle*) fPartArray->UncheckedAt(fimuon2);
87          }
88      }
89 void AliDimuCombinator::FirstPartnerSelected()
90 {
91          FirstPartner();
92          while(fmuon2 !=0 && !Selected(fmuon2)) {NextPartner();}
93 }
94
95
96  void AliDimuCombinator::NextPartner()
97      {
98          fimuon2++;
99          if (fimuon2>=fimax2) {fmuon2 = 0; return;}
100
101          
102          fmuon2 = (TParticle*) fPartArray->UncheckedAt(fimuon2);
103
104          while(Type(fmuon2)!=5 && Type(fmuon2)!=6) {
105              fimuon2++;
106              if (fimuon2>=fimax2) {fmuon2 = 0; break;}
107              fmuon2 = (TParticle*) fPartArray->UncheckedAt(fimuon2);
108          }
109
110      }
111
112 void AliDimuCombinator::NextPartnerSelected()
113 {
114          NextPartner();
115          while(fmuon2 !=0 && !Selected(fmuon2)) {NextPartner();}
116 }
117
118
119  TParticle*  AliDimuCombinator::Partner()
120      {
121          return fmuon2;
122      }
123
124 void AliDimuCombinator::FirstMuonPair(TParticle* & muon1, TParticle* & muon2)
125      {
126          FirstMuon();
127          FirstPartner();
128          muon1=fmuon1;
129          muon2=fmuon2;   
130      }
131 void AliDimuCombinator::NextMuonPair(TParticle* & muon1, TParticle* & muon2)
132      {
133          NextPartner();
134          if (!Partner()) {
135              NextMuon();
136              FirstPartner();
137          }
138          muon1=fmuon1;
139          muon2=fmuon2;   
140      }
141 void AliDimuCombinator::FirstMuonPairSelected(TParticle* & muon1, TParticle* & muon2)
142      {
143          FirstMuonSelected();
144          FirstPartnerSelected();
145          muon1=fmuon1;
146          muon2=fmuon2;   
147      }
148 void AliDimuCombinator::NextMuonPairSelected(TParticle* & muon1, TParticle* & muon2)
149      {
150          NextPartnerSelected();
151          if (!Partner()) {
152              NextMuonSelected();
153              FirstPartnerSelected();
154          }
155          muon1=fmuon1;
156          muon2=fmuon2;   
157      }
158 void AliDimuCombinator::ResetRange()
159 {
160     fimin1=fimin2=0;
161     fimax1=fimax2=fNParticle;
162 }
163
164 void AliDimuCombinator::SetFirstRange(Int_t from, Int_t to)
165 {
166     fimin1=from;
167     fimax1=to;
168     if (fimax1 > fNParticle) fimax1=fNParticle;
169 }
170
171 void AliDimuCombinator::SetSecondRange(Int_t from, Int_t to)
172 {
173     fimin2=from;
174     fimax2=to;
175     if (fimax2 > fNParticle) fimax2=fNParticle;
176 }
177 //
178 //                       Selection
179 //
180
181 Bool_t AliDimuCombinator::Selected(TParticle* part)
182 {
183 // 
184 //
185     if (part==0) {return 0;}
186     
187     if (part->Pt() > fPtMin && part->Eta()>fEtaMin && part->Eta()<fEtaMax) {
188         return 1;
189     } else {
190         return 0;
191     }
192     
193     
194 }
195
196 Bool_t AliDimuCombinator::Selected(TParticle* part1, TParticle* part2)
197 {
198      return Selected(part1)*Selected(part2);
199 }
200 //
201 //                       Kinematics
202 //
203 Float_t AliDimuCombinator::Mass(TParticle* part1, TParticle* part2)
204 {
205     Float_t px,py,pz,e;
206     px=part1->Px()+part2->Px();
207     py=part1->Py()+part2->Py();
208     pz=part1->Pz()+part2->Pz();    
209     e =part1->Energy()+part2->Energy();
210     Float_t p=px*px+py*py+pz*pz;
211     if (e*e < p) {
212         return -1; 
213     } else {
214         return TMath::Sqrt(e*e-p);
215     }
216 }
217
218 Float_t AliDimuCombinator::PT(TParticle* part1, TParticle* part2)
219 {
220     Float_t px,py;
221     px=part1->Px()+part2->Px();
222     py=part1->Py()+part2->Py();
223     return TMath::Sqrt(px*px+py*py);
224 }
225
226 Float_t AliDimuCombinator::Pz(TParticle* part1, TParticle* part2)
227 {
228     return part1->Pz()+part2->Pz();
229 }
230
231 Float_t AliDimuCombinator::Y(TParticle* part1, TParticle* part2)
232 {
233     Float_t pz,e;
234     pz=part1->Pz()+part2->Pz();
235     e =part1->Energy()+part2->Energy();
236     return 0.5*TMath::Log((e+pz)/(e-pz));
237 }
238 //                  Response
239 //
240 void AliDimuCombinator::SmearGauss(Float_t width, Float_t & value)
241 {
242     value+=gRandom->Gaus(0, width);
243 }
244 //              Weighting
245 // 
246
247 Float_t AliDimuCombinator::Decay_Prob(TParticle* part)
248 {
249     Float_t d, h, theta, CTau;
250     TParticle* parent = Parent(part);
251     Int_t ipar=Type(parent);
252     if (ipar==8 || ipar==9) {
253         CTau=780.4;
254     } else if (ipar==11 || ipar==12) {
255         CTau=370.9;
256     } else {
257         CTau=0;
258     }
259     
260     
261     Float_t GammaBeta=(parent->P())/(parent->GetMass());
262 //
263 // this part is still very ALICE muon-arm specific
264 //
265     theta=parent->Theta();
266     h=90*TMath::Tan(theta);
267     
268     if (h<4) {
269         d=4/TMath::Sin(theta);
270     } else {
271         d=90/TMath::Cos(theta);
272     }
273     
274     if (CTau > 0) {
275         return 1-TMath::Exp(-d/CTau/GammaBeta);
276     } else {
277         return 1;
278     }
279 }
280
281 Float_t AliDimuCombinator::Weight(TParticle* part1, TParticle* part2)
282 {
283     Float_t wgt=(part1->GetWeight())*(part2->GetWeight());
284     
285     if (Correlated(part1, part2)) {
286         return wgt/(Parent(part1)->GetWeight())*fRate1;
287     } else {
288         return wgt*fRate1*fRate2;
289     }
290
291
292
293 Float_t AliDimuCombinator::Weight(TParticle* part)
294 {
295     return (part->GetWeight())*(Parent(part)->GetWeight())*fRate1;
296 }
297 Bool_t  AliDimuCombinator::Correlated(TParticle* part1, TParticle* part2)
298 {
299     if (Origin(part1) == Origin(part2)) {
300         return kTRUE;
301     } else {
302         return kFALSE;
303     }
304 }
305
306 TParticle* AliDimuCombinator::Parent(TParticle* part)
307 {
308     return (TParticle*) (fPartArray->UncheckedAt(part->GetFirstMother()));
309 }
310
311 Int_t AliDimuCombinator::Origin(TParticle* part)
312 {
313     Int_t iparent= part->GetFirstMother();
314     if (iparent < 0) return iparent;
315     Int_t ip;
316     while(1) {
317         ip=((TParticle*) fPartArray->UncheckedAt(iparent))->GetFirstMother();
318         if (ip < 0) {
319             break;
320         } else {
321             iparent=ip;
322         }
323     }
324     return iparent;
325 }
326