]>
Commit | Line | Data |
---|---|---|
4fdf4eb3 | 1 | #include "AliHBTLLWeights.h" |
88cb7938 | 2 | /************************************************************************** |
3 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
4 | * * | |
5 | * Author: The ALICE Off-line Project. * | |
6 | * Contributors are mentioned in the code where appropriate. * | |
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 | // | |
20 | // class AliHBTLLWeights | |
21 | // | |
22 | // This class introduces the weight's calculation | |
23 | // according to the Lednicky's algorithm. | |
24 | // | |
25 | // | |
26 | // fsiw.f, fsiini.f | |
27 | // | |
28 | // Description from fortran code by author R. Lednicky | |
29 | // | |
30 | // Calculates final state interaction (FSI) weights | |
31 | // WEIF = weight due to particle - (effective) nucleus FSI (p-N) | |
32 | // WEI = weight due to p-p-N FSI | |
33 | // WEIN = weight due to p-p FSI; note that WEIN=WEI if I3C=0; | |
34 | // note that if I3C=1 the calculation of | |
35 | // WEIN can be skipped by putting J=0 | |
36 | //....................................................................... | |
37 | // Correlation Functions: | |
38 | // CF(p-p-N) = sum(WEI)/sum(WEIF) | |
39 | // CF(p-p) = sum(WEIN)/sum(1); here the nucleus is completely | |
40 | // inactive | |
41 | // CF(p-p-"N") = sum(WEIN*WEIF')/sum(WEIF'), where WEIN and WEIF' | |
42 | // are not correlated (calculated at different emission | |
43 | // points, e.g., for different events); | |
44 | // thus here the nucleus affects one-particle | |
45 | // spectra but not the correlation | |
46 | //....................................................................... | |
47 | // User must supply data file <fn> on unit NUNIT (e.g. =11) specifying | |
48 | // LL : particle pair | |
49 | // NS : approximation used to calculate Bethe-Salpeter amplitude | |
50 | // ITEST: test switch | |
51 | // If ITEST=1 then also following parameters are required | |
52 | // ICH : 1(0) Coulomb interaction between the two particles ON (OFF) | |
53 | // IQS : 1(0) quantum statistics for the two particles ON (OFF) | |
54 | // ISI : 1(0) strong interaction between the two particles ON (OFF) | |
55 | // I3C : 1(0) Coulomb interaction with residual nucleus ON (OFF) | |
56 | // This data file can contain other information useful for the user. | |
57 | // It is read by subroutines READINT4 and READREA8(4) (or READ_FILE). | |
58 | // ------------------------------------------------------------------- | |
59 | //- LL 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | |
60 | //- part. 1: n p n alfa pi+ pi0 pi+ n p pi+ pi+ pi+ pi- K+ K+ K+ K- | |
61 | //- part. 2: n p p alfa pi- pi0 pi+ d d K- K+ p p K- K+ p p | |
62 | // NS=1 y/n: + + + + + - - - - - - - - - - - - | |
63 | // ------------------------------------------------------------------- | |
64 | //- LL 18 19 20 21 22 23 24 25 26 27 28 | |
65 | //- part. 1: d d t t K0 K0 d p p p n | |
66 | //- part. 2: d alfa t alfa K0 K0b t t alfa lambda lambda | |
67 | // NS=1 y/n: - - - - - - - - - + + | |
68 | // ------------------------------------------------------------------- | |
69 | // NS=1 Square well potential, | |
70 | // NS=3 not used | |
71 | // NS=4 scattered wave approximated by the spherical wave, | |
72 | // NS=2 same as NS=4 but the approx. of equal emission times in PRF | |
73 | // not required (t=0 approx. used in all other cases). | |
74 | // Note: if NS=2,4, the B-S amplitude diverges at zero distance r* in | |
75 | // the two-particle c.m.s.; user can specify a cutoff AA in | |
76 | // SUBROUTINE FSIINI, for example: | |
77 | // IF(NS.EQ.2.OR.NS.EQ.4)AA=5.D0 !! in 1/GeV --> AA=1. fm | |
78 | // ------------------------------------------------------------------ | |
79 | // ITEST=1 any values of parameters ICH, IQS, ISI, I3C are allowed | |
80 | // and should be given in data file <fn> | |
81 | // ITEST=0 physical values of these parameters are put automatically | |
82 | // in FSIINI (their values are not required in data file) | |
83 | //===================================================================== | |
84 | // At the beginning of calculation user should call FSIINI, | |
85 | // which reads LL, NS, ITEST (and eventually ICH, IQS, ISI, I3C) | |
86 | // and initializes various parameters. | |
87 | // In particular the constants in | |
88 | // COMMON/FSI_CONS/PI,PI2,SPI,DR,W | |
89 | // may be useful for the user: | |
90 | // W=1/.1973D0 ! from fm to 1/GeV | |
91 | // PI=4*DATAN(1.D0) | |
92 | // PI2=2*PI | |
93 | // SPI=DSQRT(PI) | |
94 | // DR=180.D0/PI ! from radian to degree | |
95 | // _______________________________________________________ | |
96 | // !! |Important note: all real quantities are assumed REAL*8 | !! | |
97 | // ------------------------------------------------------- | |
98 | // For each event user should fill in the following information | |
99 | // in COMMONs (all COMMONs in FSI calculation start with FSI_): | |
100 | // ................................................................... | |
101 | // COMMON/FSI_POC/AMN,AM1,AM2,CN,C1,C2,AC1,AC2 | |
102 | // Only | |
103 | // AMN = mass of the effective nucleus [GeV/c**2] | |
104 | // CN = charge of the effective nucleus [elem. charge units] | |
105 | // are required | |
106 | // ................................................................... | |
107 | // COMMON/FSI_MOM/P1X,P1Y,P1Z,E1,P1, !part. momenta in the rest frame | |
108 | // 1 P2X,P2Y,P2Z,E2,P2 !of effective nucleus (NRF) | |
109 | // Only the components | |
110 | // PiX,PiY,PiZ [GeV/c] | |
111 | // in NRF are required. | |
112 | // To make the corresponding Lorentz transformation user can use the | |
113 | // subroutines LTRAN and LTRANB | |
114 | // ................................................................... | |
115 | // COMMON/FSI_COOR/X1,Y1,Z1,T1,R1, ! 4-coord. of emission | |
116 | // 1 X2,Y2,Z2,T2,R2 ! points in NRF | |
117 | // The componets | |
118 | // Xi,Yi,Zi [fm] | |
119 | // and emission times | |
120 | // Ti [fm/c] | |
121 | // should be given in NRF with the origin assumed at the center | |
122 | // of the effective nucleus. If the effect of residual nucleus is | |
123 | // not calculated within FSIW, the NRF can be any fixed frame. | |
124 | // -------------------------------------------------------------------- | |
125 | // Before calling FSIW the user must call | |
126 | // CALL LTRAN12 | |
127 | // Besides Lorentz transformation to pair rest frame: | |
128 | // (p1-p2)/2 --> k* it also transforms 4-coordinates of | |
129 | // emission points from fm to 1/GeV and calculates Ei,Pi and Ri. | |
130 | // Note that |k*|=AK in COMMON/FSI_PRF/ | |
131 | // -------------------------------------------------------------------- | |
132 | // After making some additional filtering using k* (say k* < k*max) | |
133 | // or direction of vector k*, | |
134 | // user can finally call FSIW to calculate the FSI weights | |
135 | // to be used to construct the correlation function | |
136 | //====================================================================== | |
137 | ||
4fdf4eb3 | 138 | |
7f92929e | 139 | /*******************************************************************/ |
140 | /****** ROUTINES USED FOR COMMUNUCATION ********/ | |
141 | /******************** WITH FORTRAN ********************/ | |
142 | /*******************************************************************/ | |
143 | #ifndef WIN32 | |
144 | # define led_bldata led_bldata_ | |
145 | # define fsiini fsiini_ | |
146 | # define ltran12 ltran12_ | |
147 | # define fsiw fsiw_ | |
88cb7938 | 148 | # define setpdist setpdist_ |
7f92929e | 149 | # define type_of_call |
150 | #else | |
151 | # define led_bldata LED_BLDATA | |
152 | # define fsiini FSIINI | |
153 | # define ltran12 LTRAN12 | |
154 | # define fsiw FSIW | |
88cb7938 | 155 | # define setpdist SETPDIST |
7f92929e | 156 | # define type_of_call _stdcall |
157 | #endif | |
158 | /****************************************************************/ | |
159 | extern "C" void type_of_call led_bldata(); | |
160 | extern "C" void type_of_call fsiini(); | |
161 | extern "C" void type_of_call ltran12(); | |
162 | extern "C" void type_of_call fsiw(); | |
88cb7938 | 163 | extern "C" void type_of_call setpdist(Double_t& r); |
7f92929e | 164 | /**************************************************************/ |
165 | ||
88cb7938 | 166 | #include "AliHBTPair.h" |
167 | #include "AliHBTParticle.h" | |
168 | #include "WLedCOMMONS.h" | |
169 | #include <TList.h> | |
170 | #include <TRandom.h> | |
171 | #include <TMath.h> | |
172 | #include <TPDGCode.h> | |
173 | ||
174 | ||
7f92929e | 175 | ClassImp(AliHBTLLWeights) |
7f92929e | 176 | |
88cb7938 | 177 | AliHBTLLWeights* AliHBTLLWeights::fgLLWeights = 0x0; |
178 | const Double_t AliHBTLLWeights::fgkWcons = 1./0.1973; | |
7f92929e | 179 | |
88cb7938 | 180 | AliHBTLLWeights::AliHBTLLWeights(): |
181 | fTest(kTRUE), | |
182 | fColoumbSwitch(kTRUE), | |
183 | fQuantStatSwitch(kTRUE), | |
184 | fStrongInterSwitch(kTRUE), | |
185 | fColWithResidNuclSwitch(kTRUE), | |
186 | fNuclMass(0.0), | |
187 | fNuclCharge(0.0), | |
188 | fRandomPosition(kFALSE), | |
189 | fRadius(0.0), | |
190 | fPID1(0), | |
191 | fPID2(0), | |
192 | fSigma(0.0) | |
7f92929e | 193 | { |
88cb7938 | 194 | // Default Constructor |
7f92929e | 195 | } |
88cb7938 | 196 | /**************************************************************/ |
7f92929e | 197 | |
4fdf4eb3 | 198 | AliHBTLLWeights* AliHBTLLWeights::Instance() |
88cb7938 | 199 | { |
200 | // returns instance of class | |
201 | if (fgLLWeights) | |
202 | { | |
4fdf4eb3 | 203 | return fgLLWeights; |
88cb7938 | 204 | } |
205 | else | |
206 | { | |
207 | fgLLWeights = new AliHBTLLWeights(); | |
208 | return fgLLWeights; | |
209 | } | |
210 | } | |
211 | ||
7f92929e | 212 | |
213 | Double_t AliHBTLLWeights::GetWeight(const AliHBTPair* partpair) | |
214 | { | |
88cb7938 | 215 | // calculates weight for a pair |
216 | static const Double_t cmtofm = 1.e13; | |
217 | ||
4fdf4eb3 | 218 | AliHBTParticle *part1 = partpair->Particle1(); |
219 | AliHBTParticle *part2 = partpair->Particle2(); | |
2f8eea63 | 220 | |
4fdf4eb3 | 221 | if ( (part1 == 0x0) || (part2 == 0x0)) |
88cb7938 | 222 | { |
223 | Error("GetWeight","Null particle pointer"); | |
224 | return 0.0; | |
225 | } | |
226 | ||
227 | ||
228 | //eats a lot of time | |
4fdf4eb3 | 229 | if ( (part1->Px() == part2->Px()) && |
230 | (part1->Py() == part2->Py()) && | |
231 | (part1->Pz() == part2->Pz()) ) | |
88cb7938 | 232 | { |
233 | return 0.0; | |
234 | } | |
235 | ||
4fdf4eb3 | 236 | if ((!fRandomPosition) && |
88cb7938 | 237 | (part1->Vx() == part2->Vx()) && |
238 | (part1->Vy() == part2->Vy()) && | |
239 | (part1->Vz() == part2->Vz()) ) | |
2f8eea63 | 240 | { |
4fdf4eb3 | 241 | return 0.0; |
2f8eea63 | 242 | } |
88cb7938 | 243 | |
244 | FSI_MOM.P1X = part1->Px(); | |
245 | FSI_MOM.P1Y = part1->Py(); | |
246 | FSI_MOM.P1Z = part1->Pz(); | |
247 | ||
248 | FSI_MOM.P2X = part2->Px(); | |
249 | FSI_MOM.P2Y = part2->Py(); | |
250 | FSI_MOM.P2Z = part2->Pz(); | |
251 | ||
252 | FSI_COOR.X1 = part1->Vx()*cmtofm; | |
253 | FSI_COOR.Y1 = part1->Vy()*cmtofm; | |
254 | FSI_COOR.Z1 = part1->Vz()*cmtofm; | |
255 | FSI_COOR.T1 = part1->T(); | |
256 | ||
257 | FSI_COOR.X2 = part2->Vx()*cmtofm; | |
258 | FSI_COOR.Y2 = part2->Vy()*cmtofm; | |
259 | FSI_COOR.Z2 = part2->Vz()*cmtofm; | |
260 | FSI_COOR.T2 = part2->T(); | |
4fdf4eb3 | 261 | |
262 | ltran12(); | |
7f92929e | 263 | |
88cb7938 | 264 | //this must be after ltran12 because it would overwrite what we set below |
265 | if (fRandomPosition) | |
266 | { | |
267 | Double_t rxcm = fSigma*gRandom->Gaus(); | |
268 | Double_t rycm = fSigma*gRandom->Gaus(); | |
269 | Double_t rzcm = fSigma*gRandom->Gaus(); | |
270 | ||
271 | FSI_PRF.X=rxcm*fgkWcons; | |
272 | FSI_PRF.Y=rycm*fgkWcons; | |
273 | FSI_PRF.Z=rzcm*fgkWcons; | |
274 | FSI_PRF.T=0.; | |
275 | ||
276 | Double_t rps=rxcm*rxcm+rycm*rycm+rzcm*rzcm; | |
277 | Double_t rp=TMath::Sqrt(rps); | |
278 | setpdist(rp); | |
279 | } | |
280 | ||
281 | fsiw(); | |
4fdf4eb3 | 282 | return LEDWEIGHT.WEIN; |
283 | } | |
7f92929e | 284 | /************************************************************/ |
88cb7938 | 285 | |
7f92929e | 286 | void AliHBTLLWeights::Init() |
4fdf4eb3 | 287 | { |
88cb7938 | 288 | //initial parameters of model |
289 | ||
4fdf4eb3 | 290 | FSI_NS.NS = fApproximationModel; |
291 | ||
88cb7938 | 292 | LEDWEIGHT.ITEST = fTest; |
293 | if(fTest) | |
294 | { | |
295 | FSI_NS.ICH = fColoumbSwitch; | |
296 | FSI_NS.ISI = fStrongInterSwitch; | |
297 | FSI_NS.IQS = fQuantStatSwitch; | |
298 | FSI_NS.I3C = fColWithResidNuclSwitch; | |
299 | LEDWEIGHT.IRANPOS = fRandomPosition; | |
300 | } | |
301 | ||
4fdf4eb3 | 302 | if ( (fPID1 == 0) || (fPID2 == 0) ) |
88cb7938 | 303 | { |
304 | Fatal("Init","Particles types are not set"); | |
305 | return;//pro forma | |
306 | } | |
4fdf4eb3 | 307 | FSI_NS.LL = GetPairCode(fPID1,fPID2); |
88cb7938 | 308 | |
4fdf4eb3 | 309 | if (FSI_NS.LL == 0) |
88cb7938 | 310 | { |
311 | Fatal("Init","Particles types are not supported"); | |
312 | return;//pro forma | |
313 | } | |
314 | ||
315 | ||
4fdf4eb3 | 316 | TParticlePDG* tpart1 = TDatabasePDG::Instance()->GetParticle(fPID1); |
317 | if (tpart1 == 0x0) | |
88cb7938 | 318 | { |
319 | Fatal("init","We can not find particle with ID=%d in PDG DataBase",fPID1); | |
320 | return; | |
321 | } | |
322 | ||
4fdf4eb3 | 323 | FSI_POC.AM1=tpart1->Mass(); |
324 | FSI_POC.C1=tpart1->Charge(); | |
88cb7938 | 325 | |
4fdf4eb3 | 326 | TParticlePDG* tpart2 = TDatabasePDG::Instance()->GetParticle(fPID2); |
88cb7938 | 327 | //lv |
4fdf4eb3 | 328 | if (tpart2 == 0x0) |
88cb7938 | 329 | { |
330 | Fatal("init","We can not find particle with ID=%d in our DataBase",fPID2); | |
331 | return; | |
332 | } | |
333 | ||
4fdf4eb3 | 334 | FSI_POC.AM2=tpart2->Mass(); |
335 | FSI_POC.C1=tpart2->Charge(); | |
88cb7938 | 336 | |
4fdf4eb3 | 337 | led_bldata(); |
338 | fsiini(); | |
88cb7938 | 339 | |
340 | ||
341 | //constants for radii simulation | |
342 | ||
343 | if(fRandomPosition) | |
344 | { | |
345 | fSigma =TMath::Sqrt(2.)*fRadius; | |
346 | } | |
7f92929e | 347 | } |
88cb7938 | 348 | /************************************************************/ |
7f92929e | 349 | |
350 | Int_t AliHBTLLWeights::GetPairCode(const AliHBTPair* partpair) | |
351 | { | |
88cb7938 | 352 | //returns Code corresponding to that pair |
353 | return GetPairCode(partpair->Particle1()->GetPdgCode(),partpair->Particle2()->GetPdgCode()); | |
7f92929e | 354 | } |
88cb7938 | 355 | /************************************************************/ |
7f92929e | 356 | |
357 | Int_t AliHBTLLWeights::GetPairCode(Int_t pid1,Int_t pid2) | |
358 | { | |
88cb7938 | 359 | // returns code corresponding to the pair of PIDs |
360 | // pairCode 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | |
361 | // hpid: n p n alfa pi+ pi0 pi+ n p pi+ pi+ pi+ pi- K+ K+ K+ K- d d t t K0 K0 d p p p n | |
362 | // lpid: n p p alfa pi- pi0 pi+ d d K- K+ p p K- K+ p p d alfa t alfa K0 K0b t t alfa lambda lambda | |
363 | // NS=1 y/n: + + + + + - - - - - - - - - - - - - - - - - - - - - - - | |
364 | ||
365 | //alphas, deuterons and tyts are NOT supported here | |
366 | ||
7f92929e | 367 | Int_t chargefactor = 1; |
368 | Int_t hpid; //pid in higher row | |
369 | Int_t lpid; //pid in lower row | |
370 | Int_t code; //pairCode | |
371 | ||
372 | Bool_t swap; | |
373 | ||
88cb7938 | 374 | //determine the order of selcetion in switch |
7f92929e | 375 | if (TMath::Abs(pid1) < TMath::Abs(pid2) ) |
88cb7938 | 376 | { |
377 | if (pid1<0) chargefactor=-1; | |
378 | hpid=pid2*chargefactor; | |
379 | lpid=pid1*chargefactor; | |
380 | swap = kFALSE; | |
381 | } | |
7f92929e | 382 | else |
88cb7938 | 383 | { |
384 | if (pid2<0) chargefactor=-1; | |
385 | hpid=pid1*chargefactor; | |
386 | lpid=pid2*chargefactor; | |
387 | swap = kTRUE; | |
388 | } | |
389 | ||
390 | //mlv | |
391 | hpid=pid1; | |
392 | lpid=pid2; | |
393 | ||
394 | ||
395 | //Determine the pair code | |
7f92929e | 396 | switch (hpid) //switch on first particle id |
88cb7938 | 397 | { |
398 | case kNeutron: | |
7f92929e | 399 | switch (lpid) |
88cb7938 | 400 | { |
401 | case kNeutron: | |
402 | code = 1; //neutron neutron | |
403 | break; | |
404 | ||
405 | case kProton: | |
406 | code = 3; //neutron proton | |
407 | break; | |
408 | ||
409 | case kLambda0: | |
410 | code = 28; //neutron lambda | |
411 | break; | |
412 | ||
413 | default: | |
414 | return 0; //given pair not supported | |
415 | break; | |
416 | } | |
7f92929e | 417 | break; |
88cb7938 | 418 | |
419 | case kProton: | |
7f92929e | 420 | switch (lpid) |
88cb7938 | 421 | { |
422 | case kProton: | |
423 | code = 2; //proton proton | |
424 | break; | |
425 | ||
426 | case kLambda0: | |
427 | code = 27;//proton lambda | |
428 | break; | |
429 | ||
430 | default: | |
431 | return 0; //given pair not supported | |
432 | break; | |
433 | ||
434 | } | |
7f92929e | 435 | break; |
88cb7938 | 436 | |
437 | case kPiPlus: | |
438 | ||
7f92929e | 439 | switch (lpid) |
88cb7938 | 440 | { |
441 | case kPiPlus: | |
442 | code = 7; //piplus piplus | |
443 | break; | |
444 | ||
445 | case kPiMinus: | |
446 | code = 5; //piplus piminus | |
447 | break; | |
448 | ||
449 | case kKMinus: | |
450 | code = 10; //piplus Kminus | |
451 | break; | |
452 | ||
453 | case kKPlus: | |
454 | code = 11; //piplus Kplus | |
455 | break; | |
456 | ||
457 | case kProton: | |
458 | code = 12; //piplus proton | |
459 | chargefactor*=-1; | |
460 | break; | |
461 | ||
462 | default: | |
463 | return 0; //given pair not supported | |
464 | break; | |
465 | } | |
7f92929e | 466 | break; |
88cb7938 | 467 | case kPi0: |
7f92929e | 468 | switch (lpid) |
88cb7938 | 469 | { |
470 | case kPi0: | |
471 | code = 6; | |
472 | break; | |
473 | ||
474 | default: | |
475 | return 0; //given pair not supported | |
476 | break; | |
477 | } | |
7f92929e | 478 | break; |
479 | ||
88cb7938 | 480 | case kKPlus: |
7f92929e | 481 | switch (lpid) |
88cb7938 | 482 | { |
483 | case kKMinus: | |
484 | code = 14; //Kplus Kminus | |
485 | break; | |
486 | ||
487 | case kKPlus: | |
488 | code = 15; //Kplus Kplus | |
489 | break; | |
490 | ||
491 | case kProton: | |
492 | code = 16; //Kplus proton | |
493 | break; | |
494 | ||
495 | default: | |
496 | return 0; //given pair not supported | |
497 | break; | |
498 | } | |
7f92929e | 499 | break; |
500 | ||
88cb7938 | 501 | case kKMinus: |
7f92929e | 502 | switch (lpid) |
88cb7938 | 503 | { |
504 | case kProton: | |
505 | code = 17; //Kminus proton | |
506 | chargefactor*=1; | |
507 | break; | |
508 | ||
509 | default: | |
510 | return 0; //given pair not supported | |
511 | break; | |
512 | } | |
7f92929e | 513 | break; |
514 | ||
88cb7938 | 515 | case kK0: |
7f92929e | 516 | switch (lpid) |
88cb7938 | 517 | { |
518 | case kK0: | |
519 | code = 2; //Kzero Kzero | |
520 | break; | |
521 | ||
522 | case kK0Bar: | |
523 | code = 17; //Kzero KzeroBar | |
524 | break; | |
525 | ||
526 | default: | |
527 | return 0; //given pair not supported | |
528 | break; | |
529 | } | |
7f92929e | 530 | break; |
88cb7938 | 531 | |
532 | default: return 0; | |
533 | } | |
7f92929e | 534 | return code; |
535 | } | |
88cb7938 | 536 | /************************************************************/ |
537 | ||
538 | void AliHBTLLWeights::SetTest(Bool_t rtest) | |
539 | { | |
540 | //Sets fTest member | |
541 | fTest = rtest; | |
542 | } | |
543 | /************************************************************/ | |
544 | ||
545 | void AliHBTLLWeights::SetColoumb(Bool_t col) | |
546 | { | |
547 | // (ICH in fortran code) Coulomb interaction between the two particles ON (OFF) | |
548 | fColoumbSwitch = col; | |
549 | } | |
550 | /************************************************************/ | |
551 | ||
552 | void AliHBTLLWeights::SetQuantumStatistics(Bool_t qss) | |
553 | { | |
554 | //IQS: quantum statistics for the two particles ON (OFF) | |
555 | //if non-identical particles automatically off | |
556 | fQuantStatSwitch = qss; | |
557 | } | |
558 | /************************************************************/ | |
559 | ||
560 | void AliHBTLLWeights::SetStrongInterSwitch(Bool_t sis) | |
561 | { | |
562 | //ISI: strong interaction between the two particles ON (OFF) | |
563 | fStrongInterSwitch = sis; | |
564 | } | |
565 | /************************************************************/ | |
7f92929e | 566 | |
88cb7938 | 567 | void AliHBTLLWeights::SetColWithResidNuclSwitch(Bool_t crn) |
568 | { | |
569 | //I3C: Coulomb interaction with residual nucleus ON (OFF) | |
570 | fColWithResidNuclSwitch = crn; | |
571 | } | |
572 | /************************************************************/ | |
573 | ||
574 | void AliHBTLLWeights::SetApproxModel(Int_t ap) | |
575 | { | |
576 | //sets Model of Approximation (NS in Fortran code) | |
577 | fApproximationModel=ap; | |
578 | } | |
579 | /************************************************************/ | |
580 | ||
581 | void AliHBTLLWeights::SetRandomPosition(Bool_t rp) | |
582 | { | |
583 | //ON=kTRUE(OFF=kFALSE) | |
584 | //ON -- calculation of the Gauss source radii | |
585 | //if the generator don't allows the source generation (for example MeVSim) | |
586 | //if ON the following parameters are requested: | |
587 | fRandomPosition = rp; | |
588 | } | |
589 | /************************************************************/ | |
590 | ||
591 | void AliHBTLLWeights::SetR1dw(Double_t R) | |
592 | { | |
593 | //spherical source model radii | |
594 | fRadius=R; | |
595 | } | |
596 | /************************************************************/ | |
597 | ||
598 | void AliHBTLLWeights::SetParticlesTypes(Int_t pid1, Int_t pid2) | |
599 | { | |
600 | //set AliRoot particles types | |
601 | fPID1 = pid1; | |
602 | fPID2 = pid2; | |
603 | } | |
604 | /************************************************************/ | |
605 | ||
606 | void AliHBTLLWeights::SetNucleusCharge(Double_t ch) | |
607 | { | |
608 | // not used now (see comments in fortran code) | |
609 | fNuclCharge=ch; | |
610 | } | |
611 | /************************************************************/ | |
612 | ||
613 | void AliHBTLLWeights::SetNucleusMass(Double_t mass) | |
614 | { | |
615 | // (see comments in fortran code) | |
616 | fNuclMass=mass; | |
617 | } |