]> git.uio.no Git - u/mrichter/AliRoot.git/blame - HBTAN/AliHBTLLWeights.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Track points are moved according to vertex position so vertex is in (0,0,0)
[u/mrichter/AliRoot.git] / HBTAN / AliHBTLLWeights.cxx
CommitLineData
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)
c81f9591 86// and ializes various parameters.
88cb7938 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/****************************************************************/
159extern "C" void type_of_call led_bldata();
160extern "C" void type_of_call fsiini();
161extern "C" void type_of_call ltran12();
162extern "C" void type_of_call fsiw();
88cb7938 163extern "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"
88cb7938 169#include <TRandom.h>
170#include <TMath.h>
171#include <TPDGCode.h>
172
173
7f92929e 174ClassImp(AliHBTLLWeights)
7f92929e 175
88cb7938 176AliHBTLLWeights* AliHBTLLWeights::fgLLWeights = 0x0;
177const Double_t AliHBTLLWeights::fgkWcons = 1./0.1973;
7f92929e 178
88cb7938 179AliHBTLLWeights::AliHBTLLWeights():
180 fTest(kTRUE),
181 fColoumbSwitch(kTRUE),
182 fQuantStatSwitch(kTRUE),
183 fStrongInterSwitch(kTRUE),
111e505b 184 fColWithResidNuclSwitch(kFALSE),
88cb7938 185 fNuclMass(0.0),
186 fNuclCharge(0.0),
187 fRandomPosition(kFALSE),
188 fRadius(0.0),
526c2bd5 189 fOneMinusLambda(0.0),
88cb7938 190 fPID1(0),
191 fPID2(0),
192 fSigma(0.0)
7f92929e 193{
88cb7938 194// Default Constructor
ae4a4473 195 if (fgLLWeights)
196 Fatal("AliHBTLLWeights","LLWeights already instatiated. Use AliHBTLLWeights::Instance()");
7f92929e 197}
88cb7938 198/**************************************************************/
7f92929e 199
111e505b 200AliHBTLLWeights::AliHBTLLWeights(const AliHBTLLWeights &/*source*/):
dd82cadc 201 AliHBTWeights(),
111e505b 202 fTest(kTRUE),
203 fColoumbSwitch(kTRUE),
204 fQuantStatSwitch(kTRUE),
205 fStrongInterSwitch(kTRUE),
206 fColWithResidNuclSwitch(kFALSE),
207 fNuclMass(0.0),
208 fNuclCharge(0.0),
209 fRandomPosition(kFALSE),
210 fRadius(0.0),
526c2bd5 211 fOneMinusLambda(0.0),
111e505b 212 fPID1(0),
213 fPID2(0),
214 fSigma(0.0)
215{
216 //Copy ctor needed by the coding conventions but not used
217 Fatal("AliHBTLLWeights","copy ctor not implemented");
218}
219/************************************************************/
220
221AliHBTLLWeights& AliHBTLLWeights::operator=(const AliHBTLLWeights& /*source*/)
222{
223 //Assignment operator needed by the coding conventions but not used
224 Fatal("AliHBTLLWeights","assignment operator not implemented");
225 return * this;
226}
227/************************************************************/
228
4fdf4eb3 229AliHBTLLWeights* AliHBTLLWeights::Instance()
88cb7938 230{
231// returns instance of class
232 if (fgLLWeights)
233 {
4fdf4eb3 234 return fgLLWeights;
88cb7938 235 }
236 else
237 {
238 fgLLWeights = new AliHBTLLWeights();
239 return fgLLWeights;
240 }
241}
526c2bd5 242/************************************************************/
7f92929e 243
dd82cadc 244void AliHBTLLWeights::Set()
245{
246 //sets this as weighitng class
247 Info("Set","Setting Lednicky-Lyuboshitz as Weighing Class");
248
249 if ( fgWeights == 0x0 )
250 {
251 fgWeights = AliHBTLLWeights::Instance();
252 return;
253 }
254 if ( fgWeights == AliHBTLLWeights::Instance() ) return;
255 delete fgWeights;
256 fgWeights = AliHBTLLWeights::Instance();
257}
258/************************************************************/
259
7f92929e 260Double_t AliHBTLLWeights::GetWeight(const AliHBTPair* partpair)
261{
88cb7938 262// calculates weight for a pair
37e71815 263 static const Double_t kcmtofm = 1.e13;
264 static const Double_t kcmtoOneOverGeV = kcmtofm*fgkWcons;
88cb7938 265
4fdf4eb3 266 AliHBTParticle *part1 = partpair->Particle1();
267 AliHBTParticle *part2 = partpair->Particle2();
2f8eea63 268
4fdf4eb3 269 if ( (part1 == 0x0) || (part2 == 0x0))
88cb7938 270 {
271 Error("GetWeight","Null particle pointer");
272 return 0.0;
273 }
274
72e72d00 275 if ( fPID1 != part1->GetPdgCode() ) return 1.0;
276 if ( fPID2 != part2->GetPdgCode() ) return 1.0;
88cb7938 277
526c2bd5 278//takes a lot of time
4fdf4eb3 279 if ( (part1->Px() == part2->Px()) &&
280 (part1->Py() == part2->Py()) &&
281 (part1->Pz() == part2->Pz()) )
88cb7938 282 {
283 return 0.0;
284 }
285
4fdf4eb3 286 if ((!fRandomPosition) &&
88cb7938 287 (part1->Vx() == part2->Vx()) &&
288 (part1->Vy() == part2->Vy()) &&
289 (part1->Vz() == part2->Vz()) )
2f8eea63 290 {
4fdf4eb3 291 return 0.0;
2f8eea63 292 }
88cb7938 293
526c2bd5 294 if(fOneMinusLambda)//implemetation of non-zero intetcept parameter
295 {
296 if( gRandom->Rndm() < fOneMinusLambda ) return 1.0;
297 }
298
88cb7938 299 FSI_MOM.P1X = part1->Px();
300 FSI_MOM.P1Y = part1->Py();
301 FSI_MOM.P1Z = part1->Pz();
302
303 FSI_MOM.P2X = part2->Px();
304 FSI_MOM.P2Y = part2->Py();
305 FSI_MOM.P2Z = part2->Pz();
306
37e71815 307 FSI_COOR.X1 = part1->Vx()*kcmtoOneOverGeV;
308 FSI_COOR.Y1 = part1->Vy()*kcmtoOneOverGeV;
309 FSI_COOR.Z1 = part1->Vz()*kcmtoOneOverGeV;
88cb7938 310 FSI_COOR.T1 = part1->T();
311
37e71815 312 FSI_COOR.X2 = part2->Vx()*kcmtoOneOverGeV;
313 FSI_COOR.Y2 = part2->Vy()*kcmtoOneOverGeV;
314 FSI_COOR.Z2 = part2->Vz()*kcmtoOneOverGeV;
88cb7938 315 FSI_COOR.T2 = part2->T();
4fdf4eb3 316
317 ltran12();
7f92929e 318
88cb7938 319 //this must be after ltran12 because it would overwrite what we set below
320 if (fRandomPosition)
321 {
322 Double_t rxcm = fSigma*gRandom->Gaus();
323 Double_t rycm = fSigma*gRandom->Gaus();
324 Double_t rzcm = fSigma*gRandom->Gaus();
325
326 FSI_PRF.X=rxcm*fgkWcons;
327 FSI_PRF.Y=rycm*fgkWcons;
328 FSI_PRF.Z=rzcm*fgkWcons;
329 FSI_PRF.T=0.;
330
331 Double_t rps=rxcm*rxcm+rycm*rycm+rzcm*rzcm;
332 Double_t rp=TMath::Sqrt(rps);
333 setpdist(rp);
334 }
335
336 fsiw();
4fdf4eb3 337 return LEDWEIGHT.WEIN;
338}
7f92929e 339/************************************************************/
88cb7938 340
7f92929e 341void AliHBTLLWeights::Init()
4fdf4eb3 342{
88cb7938 343//initial parameters of model
344
4fdf4eb3 345 FSI_NS.NS = fApproximationModel;
346
88cb7938 347 LEDWEIGHT.ITEST = fTest;
348 if(fTest)
349 {
350 FSI_NS.ICH = fColoumbSwitch;
351 FSI_NS.ISI = fStrongInterSwitch;
352 FSI_NS.IQS = fQuantStatSwitch;
353 FSI_NS.I3C = fColWithResidNuclSwitch;
354 LEDWEIGHT.IRANPOS = fRandomPosition;
355 }
356
4fdf4eb3 357 if ( (fPID1 == 0) || (fPID2 == 0) )
88cb7938 358 {
359 Fatal("Init","Particles types are not set");
360 return;//pro forma
361 }
c81f9591 362
363
4fdf4eb3 364 FSI_NS.LL = GetPairCode(fPID1,fPID2);
88cb7938 365
4fdf4eb3 366 if (FSI_NS.LL == 0)
88cb7938 367 {
368 Fatal("Init","Particles types are not supported");
369 return;//pro forma
370 }
371
c81f9591 372 Info("Init","Setting PIDs %d %d. LL Code is %d",fPID1,fPID2,FSI_NS.LL);
373
88cb7938 374
4fdf4eb3 375 TParticlePDG* tpart1 = TDatabasePDG::Instance()->GetParticle(fPID1);
376 if (tpart1 == 0x0)
88cb7938 377 {
378 Fatal("init","We can not find particle with ID=%d in PDG DataBase",fPID1);
379 return;
380 }
381
4fdf4eb3 382 FSI_POC.AM1=tpart1->Mass();
383 FSI_POC.C1=tpart1->Charge();
88cb7938 384
4fdf4eb3 385 TParticlePDG* tpart2 = TDatabasePDG::Instance()->GetParticle(fPID2);
88cb7938 386//lv
4fdf4eb3 387 if (tpart2 == 0x0)
88cb7938 388 {
389 Fatal("init","We can not find particle with ID=%d in our DataBase",fPID2);
390 return;
391 }
392
4fdf4eb3 393 FSI_POC.AM2=tpart2->Mass();
394 FSI_POC.C1=tpart2->Charge();
88cb7938 395
4fdf4eb3 396 led_bldata();
397 fsiini();
88cb7938 398
399
400//constants for radii simulation
401
402 if(fRandomPosition)
403 {
404 fSigma =TMath::Sqrt(2.)*fRadius;
405 }
7f92929e 406}
88cb7938 407/************************************************************/
7f92929e 408
409Int_t AliHBTLLWeights::GetPairCode(const AliHBTPair* partpair)
410{
88cb7938 411//returns Code corresponding to that pair
412 return GetPairCode(partpair->Particle1()->GetPdgCode(),partpair->Particle2()->GetPdgCode());
7f92929e 413}
88cb7938 414/************************************************************/
7f92929e 415
416Int_t AliHBTLLWeights::GetPairCode(Int_t pid1,Int_t pid2)
417{
88cb7938 418// returns code corresponding to the pair of PIDs
419// 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
420// 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
421// 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
422// NS=1 y/n: + + + + + - - - - - - - - - - - - - - - - - - - - - - -
423
424//alphas, deuterons and tyts are NOT supported here
425
7f92929e 426 Int_t chargefactor = 1;
427 Int_t hpid; //pid in higher row
428 Int_t lpid; //pid in lower row
429 Int_t code; //pairCode
430
431 Bool_t swap;
432
88cb7938 433//determine the order of selcetion in switch
7f92929e 434 if (TMath::Abs(pid1) < TMath::Abs(pid2) )
88cb7938 435 {
436 if (pid1<0) chargefactor=-1;
437 hpid=pid2*chargefactor;
438 lpid=pid1*chargefactor;
439 swap = kFALSE;
440 }
7f92929e 441 else
88cb7938 442 {
443 if (pid2<0) chargefactor=-1;
444 hpid=pid1*chargefactor;
445 lpid=pid2*chargefactor;
446 swap = kTRUE;
447 }
448
449//mlv
450 hpid=pid1;
451 lpid=pid2;
452
453
454//Determine the pair code
7f92929e 455 switch (hpid) //switch on first particle id
88cb7938 456 {
457 case kNeutron:
7f92929e 458 switch (lpid)
88cb7938 459 {
460 case kNeutron:
461 code = 1; //neutron neutron
462 break;
463
464 case kProton:
465 code = 3; //neutron proton
466 break;
467
468 case kLambda0:
469 code = 28; //neutron lambda
470 break;
471
472 default:
473 return 0; //given pair not supported
474 break;
475 }
7f92929e 476 break;
88cb7938 477
478 case kProton:
7f92929e 479 switch (lpid)
88cb7938 480 {
481 case kProton:
482 code = 2; //proton proton
483 break;
484
485 case kLambda0:
486 code = 27;//proton lambda
487 break;
488
489 default:
490 return 0; //given pair not supported
491 break;
492
493 }
7f92929e 494 break;
88cb7938 495
496 case kPiPlus:
497
7f92929e 498 switch (lpid)
88cb7938 499 {
500 case kPiPlus:
501 code = 7; //piplus piplus
502 break;
503
504 case kPiMinus:
505 code = 5; //piplus piminus
506 break;
507
508 case kKMinus:
509 code = 10; //piplus Kminus
510 break;
511
512 case kKPlus:
513 code = 11; //piplus Kplus
514 break;
515
516 case kProton:
517 code = 12; //piplus proton
518 chargefactor*=-1;
519 break;
520
521 default:
522 return 0; //given pair not supported
523 break;
524 }
7f92929e 525 break;
88cb7938 526 case kPi0:
7f92929e 527 switch (lpid)
88cb7938 528 {
529 case kPi0:
530 code = 6;
531 break;
532
533 default:
534 return 0; //given pair not supported
535 break;
536 }
7f92929e 537 break;
538
88cb7938 539 case kKPlus:
7f92929e 540 switch (lpid)
88cb7938 541 {
542 case kKMinus:
543 code = 14; //Kplus Kminus
544 break;
545
546 case kKPlus:
547 code = 15; //Kplus Kplus
548 break;
549
550 case kProton:
551 code = 16; //Kplus proton
552 break;
553
554 default:
555 return 0; //given pair not supported
556 break;
557 }
7f92929e 558 break;
559
88cb7938 560 case kKMinus:
7f92929e 561 switch (lpid)
88cb7938 562 {
563 case kProton:
564 code = 17; //Kminus proton
565 chargefactor*=1;
566 break;
567
568 default:
569 return 0; //given pair not supported
570 break;
571 }
7f92929e 572 break;
573
88cb7938 574 case kK0:
7f92929e 575 switch (lpid)
88cb7938 576 {
577 case kK0:
578 code = 2; //Kzero Kzero
579 break;
580
581 case kK0Bar:
582 code = 17; //Kzero KzeroBar
583 break;
584
585 default:
586 return 0; //given pair not supported
587 break;
588 }
7f92929e 589 break;
88cb7938 590
591 default: return 0;
592 }
7f92929e 593 return code;
594}
88cb7938 595/************************************************************/
596
597void AliHBTLLWeights::SetTest(Bool_t rtest)
598{
599 //Sets fTest member
600 fTest = rtest;
601}
602/************************************************************/
603
604void AliHBTLLWeights::SetColoumb(Bool_t col)
605{
606 // (ICH in fortran code) Coulomb interaction between the two particles ON (OFF)
607 fColoumbSwitch = col;
608}
609/************************************************************/
610
611void AliHBTLLWeights::SetQuantumStatistics(Bool_t qss)
612{
613 //IQS: quantum statistics for the two particles ON (OFF)
614 //if non-identical particles automatically off
615 fQuantStatSwitch = qss;
616}
617/************************************************************/
618
619void AliHBTLLWeights::SetStrongInterSwitch(Bool_t sis)
620{
621 //ISI: strong interaction between the two particles ON (OFF)
622 fStrongInterSwitch = sis;
623}
624/************************************************************/
7f92929e 625
88cb7938 626void AliHBTLLWeights::SetColWithResidNuclSwitch(Bool_t crn)
627{
628 //I3C: Coulomb interaction with residual nucleus ON (OFF)
629 fColWithResidNuclSwitch = crn;
630}
631/************************************************************/
632
633void AliHBTLLWeights::SetApproxModel(Int_t ap)
634{
635 //sets Model of Approximation (NS in Fortran code)
636 fApproximationModel=ap;
637}
638/************************************************************/
639
640void AliHBTLLWeights::SetRandomPosition(Bool_t rp)
641{
642 //ON=kTRUE(OFF=kFALSE)
643 //ON -- calculation of the Gauss source radii
644 //if the generator don't allows the source generation (for example MeVSim)
645 //if ON the following parameters are requested:
646 fRandomPosition = rp;
647}
648/************************************************************/
649
650void AliHBTLLWeights::SetR1dw(Double_t R)
651{
652 //spherical source model radii
653 fRadius=R;
654}
655/************************************************************/
656
657void AliHBTLLWeights::SetParticlesTypes(Int_t pid1, Int_t pid2)
658{
659 //set AliRoot particles types
660 fPID1 = pid1;
661 fPID2 = pid2;
662}
663/************************************************************/
664
665void AliHBTLLWeights::SetNucleusCharge(Double_t ch)
666{
667 // not used now (see comments in fortran code)
668 fNuclCharge=ch;
669}
670/************************************************************/
671
672void AliHBTLLWeights::SetNucleusMass(Double_t mass)
673{
674 // (see comments in fortran code)
675 fNuclMass=mass;
676}