Retrifit last developements from 4.01.Release

[u/mrichter/AliRoot.git] / HBTAN / AliHBTPositionRandomizer.cxx

diff --git a/HBTAN/AliHBTPositionRandomizer.cxx b/HBTAN/AliHBTPositionRandomizer.cxx
index 2e6d6ad81310bc562c83685092edc475f89aa19e..3a271659bf0d2d88ce4e6f9a8f76a90ad580aa1c 100644 (file)
--- a/HBTAN/AliHBTPositionRandomizer.cxx
+++ b/HBTAN/AliHBTPositionRandomizer.cxx
@@ -16,12 +16,16 @@
 
 ClassImp(AliHBTPositionRandomizer)
 
+const Int_t AliHBTPositionRandomizer::fgkNumberOfPids = 10;
+
 /*********************************************************************/
 
 AliHBTPositionRandomizer::AliHBTPositionRandomizer():
  fReader(0x0),
- fRandomizer(0x0),
- fModel(0),
+ fDefaultRandomizer(0x0),
+ fRandomizers(0x0),
+ fNPid(0),
+ fPids(0x0),
  fAddToExistingPos(kFALSE),
  fOnlyParticlesFromVertex(kFALSE),
  fRandomizeTracks(kFALSE),
@@ -35,8 +39,9 @@ AliHBTPositionRandomizer::AliHBTPositionRandomizer():
 
 AliHBTPositionRandomizer::AliHBTPositionRandomizer(AliReader* reader):
  fReader(reader),
- fRandomizer(new AliHBTRndmGaussBall(8.0)),
- fModel(0),
+ fRandomizers(new TObjArray(fgkNumberOfPids)),
+ fNPid(1),
+ fPids(new Int_t[fgkNumberOfPids]),
  fAddToExistingPos(kFALSE),
  fOnlyParticlesFromVertex(kFALSE),
  fRandomizeTracks(kFALSE),
@@ -45,14 +50,16 @@ AliHBTPositionRandomizer::AliHBTPositionRandomizer(AliReader* reader):
  fVZ(0.0)
 {
 //constructor
+ fRandomizers->AddAt(new AliHBTRndmGaussBall(8.0,0.0,0.0),0);
 } 
 /*********************************************************************/
 
 AliHBTPositionRandomizer::AliHBTPositionRandomizer(const AliHBTPositionRandomizer& in):
  AliReader(in),
  fReader(),
- fRandomizer(0x0),
- fModel(0),
+ fRandomizers(0x0),
+ fNPid(0),
+ fPids(0x0),
  fAddToExistingPos(kFALSE),
  fOnlyParticlesFromVertex(kFALSE),
  fRandomizeTracks(kFALSE),
@@ -68,7 +75,8 @@ AliHBTPositionRandomizer::~AliHBTPositionRandomizer()
 {
   //dtor
   delete fReader;
-  delete fRandomizer;
+  delete fRandomizers;
+  delete [] fPids;
 }
 /*********************************************************************/
 AliHBTPositionRandomizer& AliHBTPositionRandomizer::operator=(const AliHBTPositionRandomizer& in)
@@ -130,7 +138,8 @@ void AliHBTPositionRandomizer::Randomize(AliAOD* event) const
    {
      AliVAODParticle* p = event->GetParticle(i);
      Double_t x,y,z,t=0.0;
-     fRandomizer->Randomize(x,y,z,p);
+     AliHBTRndm* r = GetRandomizer(p->GetPdgCode());
+     r->Randomize(x,y,z,t,p);
      
      Double_t nx = x*kfmtocm;
      Double_t ny = y*kfmtocm;
@@ -150,26 +159,78 @@ void AliHBTPositionRandomizer::Randomize(AliAOD* event) const
 }
 /*********************************************************************/
 
-void AliHBTPositionRandomizer::SetGaussianBall(Double_t r)
+AliHBTRndm* AliHBTPositionRandomizer::GetRandomizer(Int_t pdg) const
+{
+  //returns randomizer for a given pdg 
+  Int_t idx = GetRandomizerIndex(pdg);//in most of cases 
+  if (idx < 0) idx = 0;//if not found return a default one
+  return (AliHBTRndm*)fRandomizers->At(idx);
+}
+/*********************************************************************/
+Int_t AliHBTPositionRandomizer::GetRandomizerIndex(Int_t pdg) const
+{
+  //returns randomizer index for a given pdg 
+
+  if (pdg == 0) return 0;
+  
+  for (Int_t i=1; i < fNPid; i++)
+   {
+     if (fPids[i] == pdg) 
+      return i;
+   }
+   
+  return -1;
+}
+/*********************************************************************/
+
+void AliHBTPositionRandomizer::SetRandomizer(Int_t pid, AliHBTRndm* rndm)
+{
+ //sets the randomizer for a given particle type
+  if (rndm == 0x0)
+   {
+     Error("SetRandomizer","Randomizer is null");
+     return;
+   }
+   
+  Int_t idx = GetRandomizerIndex(pid);
+  if (idx >= 0) 
+   {
+     delete fRandomizers->At(idx);
+     fRandomizers->AddAt(rndm,idx);
+   }  
+  
+  if (fNPid == fgkNumberOfPids)
+   {
+     Error("SetRandomizer","There is no more space in the array");
+     return;
+   }
+
+  fPids[fNPid] = pid;
+  fRandomizers->AddAt(rndm,fNPid);
+  fNPid++;
+}
+/*********************************************************************/
+
+void AliHBTPositionRandomizer::SetGaussianBall(Int_t pid, Double_t r, Double_t meantime, Double_t sigmatime)
 {
  //Sets Gaussian Ball Model
-  SetGaussianBall(r,r,r);
+  SetGaussianBall(pid,r,r,r,meantime,sigmatime);
 }
 /*********************************************************************/
 
-void AliHBTPositionRandomizer::SetGaussianBall(Double_t rx, Double_t ry, Double_t rz)
+void AliHBTPositionRandomizer::SetGaussianBall(Int_t pid, Double_t rx, Double_t ry, Double_t rz, Double_t meantime, Double_t sigmatime)
 {
  //Sets Gaussian Ball Model
-  delete fRandomizer;
-  fRandomizer = new AliHBTRndmGaussBall(rx,ry,rz);
+  AliHBTRndm* rndm = new AliHBTRndmGaussBall(rx,ry,rz,meantime,sigmatime);
+  SetRandomizer(pid,rndm);
 }
 /*********************************************************************/
 
-void AliHBTPositionRandomizer::SetCyllinderSurface(Double_t r, Double_t l)
+void AliHBTPositionRandomizer::SetCyllinderSurface(Int_t pid, Double_t r, Double_t l)
 {
  //Sets Cylinder Surface Model
-  delete fRandomizer;
-  fRandomizer = new  AliHBTRndmCyllSurf(r,l);
+  AliHBTRndm* rndm = new  AliHBTRndmCyllSurf(r,l);
+  SetRandomizer(pid,rndm);
 }
 /*********************************************************************/
 
@@ -182,10 +243,11 @@ void AliHBTPositionRandomizer::SetEventVertex(Double_t x, Double_t y,Double_t z)
 }
 
 
-void AliHBTPositionRandomizer::SetEllipse(Double_t rx, Double_t ryz)
+void AliHBTPositionRandomizer::SetEllipse(Int_t pid, Double_t rx, Double_t ryz)
 {
-   delete fRandomizer;
-   fRandomizer = new AliHBTRndmEllipse(rx,ryz);
+//sets the ellipse randomization for the given pid
+  AliHBTRndm* rndm = new AliHBTRndmEllipse(rx,ryz);
+  SetRandomizer(pid,rndm);   
 }
 
 /*********************************************************************/
@@ -199,25 +261,31 @@ void AliHBTPositionRandomizer::SetEllipse(Double_t rx, Double_t ryz)
 AliHBTRndmGaussBall::AliHBTRndmGaussBall():
  fRx(0.0),
  fRy(0.0),
- fRz(0.0)
+ fRz(0.0),
+ fTmean(0.0),
+ fTsigma(0.0)
 {
   //constructor
 }
 /*********************************************************************/
 
-AliHBTRndmGaussBall::AliHBTRndmGaussBall(Float_t r):
+AliHBTRndmGaussBall::AliHBTRndmGaussBall(Float_t r, Double_t meantime, Double_t sigmatime):
  fRx(r),
  fRy(r),
- fRz(r)
+ fRz(r),
+ fTmean(meantime),
+ fTsigma(sigmatime)
 {
   //constructor
 }
 /*********************************************************************/
 
-AliHBTRndmGaussBall::AliHBTRndmGaussBall(Float_t rx, Float_t ry, Float_t rz):
+AliHBTRndmGaussBall::AliHBTRndmGaussBall(Float_t rx, Float_t ry, Float_t rz, Double_t meantime, Double_t sigmatime):
  fRx(rx),
  fRy(ry),
- fRz(rz)
+ fRz(rz),
+ fTmean(meantime),
+ fTsigma(sigmatime)
 {
   //constructor
 }
@@ -233,12 +301,21 @@ AliHBTRndmEllipse::AliHBTRndmEllipse(Float_t rmin, Float_t rmax):
 
 /*********************************************************************/
 
-void AliHBTRndmGaussBall::Randomize(Double_t& x,Double_t& y,Double_t&z, AliVAODParticle*/*particle*/) const
+void AliHBTRndmGaussBall::Randomize(Double_t& x,Double_t& y,Double_t&z,Double_t&t, AliVAODParticle*/*particle*/) const
 {
 //randomizez gauss for each coordinate separately
   x = gRandom->Gaus(0.0,fRx);
   y = gRandom->Gaus(0.0,fRy);
   z = gRandom->Gaus(0.0,fRz);
+  
+  if (fTsigma == 0.0)
+   {
+     t = 0.0;
+     return;
+   }
+  
+  t = gRandom->Gaus(fTmean,fTsigma);
+    
 }
 /*********************************************************************/
 //_____________________________________________________________________
@@ -248,7 +325,7 @@ void AliHBTRndmGaussBall::Randomize(Double_t& x,Double_t& y,Double_t&z, AliVAODP
 //                                                                   //
 ///////////////////////////////////////////////////////////////////////
 
-void AliHBTRndmCyllSurf::Randomize(Double_t& x,Double_t& y,Double_t&z, AliVAODParticle* particle) const
+void AliHBTRndmCyllSurf::Randomize(Double_t& x,Double_t& y,Double_t&z,Double_t&/*t*/, AliVAODParticle* particle) const
 {
 //Randomizes x,y,z
    Double_t r = fR + gRandom->Gaus(0.0, 1.0);
@@ -262,7 +339,7 @@ void AliHBTRndmCyllSurf::Randomize(Double_t& x,Double_t& y,Double_t&z, AliVAODPa
 /*********************************************************************/
 /*********************************************************************/
 
-void AliHBTRndmEllipse::Randomize(Double_t& x, Double_t& y, Double_t& z,AliVAODParticle*p) const
+void AliHBTRndmEllipse::Randomize(Double_t& x, Double_t& y, Double_t& z,Double_t&/*t*/, AliVAODParticle*p) const
 {
     // p=0; //workaround - fix this damn little thingy
    double R;