reverting to prev.
[u/mrichter/AliRoot.git] / HBTAN / AliHBTLLWeights.cxx
1 #include "AliHBTLLWeights.h"
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 ializes 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
138
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_
148 # define setpdist setpdist_
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
155 # define setpdist SETPDIST
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();
163 extern "C" void type_of_call setpdist(Double_t& r);
164 /**************************************************************/
165
166 #include "AliHBTPair.h"
167 #include "AliHBTParticle.h"
168 #include "WLedCOMMONS.h"
169 #include <TRandom.h>   
170 #include <TMath.h>     
171 #include <TPDGCode.h>
172
173
174 ClassImp(AliHBTLLWeights)  
175  
176 AliHBTLLWeights* AliHBTLLWeights::fgLLWeights = 0x0; 
177 const Double_t AliHBTLLWeights::fgkWcons = 1./0.1973;
178
179 AliHBTLLWeights::AliHBTLLWeights():
180  fTest(kTRUE),
181  fColoumbSwitch(kTRUE),
182  fQuantStatSwitch(kTRUE),
183  fStrongInterSwitch(kTRUE),
184  fColWithResidNuclSwitch(kFALSE),
185  fNuclMass(0.0),
186  fNuclCharge(0.0),
187  fRandomPosition(kFALSE),
188  fRadius(0.0),
189  fOneMinusLambda(0.0),
190  fPID1(0),
191  fPID2(0),
192  fSigma(0.0)
193 {
194 // Default Constructor 
195   if (fgLLWeights)
196    Fatal("AliHBTLLWeights","LLWeights already instatiated. Use AliHBTLLWeights::Instance()");
197 }
198 /**************************************************************/
199
200 AliHBTLLWeights::AliHBTLLWeights(const AliHBTLLWeights &/*source*/):
201  AliHBTWeights(),
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),
211  fOneMinusLambda(0.0),
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
221 AliHBTLLWeights& 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
229 AliHBTLLWeights* AliHBTLLWeights::Instance()
230 {     
231 // returns instance of class 
232  if (fgLLWeights) 
233   {
234     return fgLLWeights;
235   } 
236  else 
237   {
238    fgLLWeights = new AliHBTLLWeights();            
239    return fgLLWeights; 
240   } 
241 }     
242 /************************************************************/
243
244 void 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
260 Double_t AliHBTLLWeights::GetWeight(const AliHBTPair* partpair)
261 {
262 // calculates weight for a pair
263   static const Double_t kcmtofm = 1.e13;
264   static const Double_t kcmtoOneOverGeV = kcmtofm*fgkWcons;  
265   
266   AliHBTParticle *part1 = partpair->Particle1();
267   AliHBTParticle *part2 = partpair->Particle2();
268
269   if ( (part1 == 0x0) || (part2 == 0x0))
270    {
271      Error("GetWeight","Null particle pointer");
272      return 0.0;
273    }
274
275   if ( fPID1 != part1->GetPdgCode() ) return 1.0; 
276   if ( fPID2 != part2->GetPdgCode() ) return 1.0; 
277
278 //takes a lot of time
279   if ( (part1->Px() == part2->Px()) && 
280        (part1->Py() == part2->Py()) && 
281        (part1->Pz() == part2->Pz()) )
282    {
283      return 0.0;
284    }
285
286   if ((!fRandomPosition) && 
287       (part1->Vx()  == part2->Vx()) && 
288       (part1->Vy()  == part2->Vy()) && 
289       (part1->Vz()  == part2->Vz()) )
290     {        
291       return 0.0;
292     }
293
294   if(fOneMinusLambda)//implemetation of non-zero intetcept parameter 
295    {
296      if( gRandom->Rndm() < fOneMinusLambda ) return 1.0;
297    }
298     
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
307   FSI_COOR.X1 = part1->Vx()*kcmtoOneOverGeV;
308   FSI_COOR.Y1 = part1->Vy()*kcmtoOneOverGeV;
309   FSI_COOR.Z1 = part1->Vz()*kcmtoOneOverGeV;
310   FSI_COOR.T1 = part1->T();
311
312   FSI_COOR.X2 = part2->Vx()*kcmtoOneOverGeV;
313   FSI_COOR.Y2 = part2->Vy()*kcmtoOneOverGeV;
314   FSI_COOR.Z2 = part2->Vz()*kcmtoOneOverGeV;
315   FSI_COOR.T2 = part2->T();
316   
317   ltran12();
318
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();
337   return LEDWEIGHT.WEIN;
338 }
339 /************************************************************/
340
341 void AliHBTLLWeights::Init()
342 {
343 //initial parameters of model
344
345   FSI_NS.NS = fApproximationModel;      
346   
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  
357   if ( (fPID1 == 0) || (fPID2 == 0) )
358    {
359      Fatal("Init","Particles types are not set");
360      return;//pro forma
361    }
362   
363   
364   FSI_NS.LL = GetPairCode(fPID1,fPID2);
365        
366   if (FSI_NS.LL == 0) 
367    {
368      Fatal("Init","Particles types are not supported");
369      return;//pro forma
370    }
371
372   Info("Init","Setting PIDs %d %d. LL Code is %d",fPID1,fPID2,FSI_NS.LL);
373
374
375   TParticlePDG* tpart1 = TDatabasePDG::Instance()->GetParticle(fPID1);
376   if (tpart1 == 0x0)
377    {
378      Fatal("init","We can not find particle with ID=%d in PDG DataBase",fPID1);
379      return;
380    }
381       
382   FSI_POC.AM1=tpart1->Mass();
383   FSI_POC.C1=tpart1->Charge(); 
384
385   TParticlePDG* tpart2 = TDatabasePDG::Instance()->GetParticle(fPID2);
386 //lv
387   if (tpart2 == 0x0)
388    {
389      Fatal("init","We can not find particle with ID=%d in our DataBase",fPID2);
390      return;
391    }
392
393   FSI_POC.AM2=tpart2->Mass();
394   FSI_POC.C1=tpart2->Charge();
395
396   led_bldata();
397   fsiini();
398
399
400 //constants for radii simulation 
401
402   if(fRandomPosition)
403    {
404      fSigma =TMath::Sqrt(2.)*fRadius;     
405    } 
406
407 /************************************************************/
408
409 Int_t AliHBTLLWeights::GetPairCode(const AliHBTPair* partpair)
410 {
411 //returns Code corresponding to that pair
412  return GetPairCode(partpair->Particle1()->GetPdgCode(),partpair->Particle2()->GetPdgCode());
413 }
414 /************************************************************/
415
416 Int_t AliHBTLLWeights::GetPairCode(Int_t pid1,Int_t pid2)
417 {
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
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   
433 //determine the order of selcetion in switch  
434   if (TMath::Abs(pid1) < TMath::Abs(pid2) ) 
435    {
436     if (pid1<0) chargefactor=-1;
437     hpid=pid2*chargefactor;
438     lpid=pid1*chargefactor;
439     swap = kFALSE;
440    } 
441   else 
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
455   switch (hpid) //switch on first  particle id
456    {
457      case kNeutron:
458       switch (lpid)
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        }
476       break;
477
478      case kProton:
479       switch (lpid)
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        }
494       break;
495
496      case kPiPlus:
497      
498       switch (lpid)
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        }
525       break;
526      case kPi0:
527       switch (lpid)
528        {
529          case kPi0:
530            code = 6;
531            break;
532            
533          default: 
534            return 0; //given pair not supported
535            break;
536        }
537       break;
538       
539      case kKPlus:
540       switch (lpid)
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        }
558       break;
559       
560      case kKMinus:
561       switch (lpid)
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        }
572       break;
573       
574      case kK0:
575       switch (lpid)
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        }
589       break;
590
591      default: return 0;
592    }
593   return code;
594 }
595 /************************************************************/
596
597 void AliHBTLLWeights::SetTest(Bool_t rtest)
598 {
599   //Sets fTest member
600   fTest = rtest;
601
602 /************************************************************/
603
604 void 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
611 void 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
619 void AliHBTLLWeights::SetStrongInterSwitch(Bool_t sis)
620 {
621   //ISI: strong interaction between the two particles ON (OFF)
622   fStrongInterSwitch = sis;
623 }
624 /************************************************************/
625
626 void AliHBTLLWeights::SetColWithResidNuclSwitch(Bool_t crn)
627 {
628   //I3C: Coulomb interaction with residual nucleus ON (OFF)  
629   fColWithResidNuclSwitch = crn;
630 }
631 /************************************************************/
632
633 void AliHBTLLWeights::SetApproxModel(Int_t ap)
634 {
635   //sets  Model of Approximation (NS in Fortran code)
636   fApproximationModel=ap;
637 }
638 /************************************************************/
639      
640 void 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
650 void AliHBTLLWeights::SetR1dw(Double_t R)
651 {
652   //spherical source model radii
653   fRadius=R;
654 }
655 /************************************************************/
656
657 void AliHBTLLWeights::SetParticlesTypes(Int_t pid1, Int_t pid2)
658 {
659   //set AliRoot particles types   
660   fPID1 = pid1; 
661   fPID2 = pid2;
662 }
663 /************************************************************/
664     
665 void AliHBTLLWeights::SetNucleusCharge(Double_t ch)
666 {
667   // not used now  (see comments in fortran code)
668   fNuclCharge=ch;
669 }
670 /************************************************************/
671
672 void AliHBTLLWeights::SetNucleusMass(Double_t mass)
673 {
674   // (see comments in fortran code)
675   fNuclMass=mass;
676 }