HBTAN/AliHBTPositionRandomizer.cxx

   1 #include "AliHBTPositionRandomizer.h"
   2 //___________________________________________________
   3 ////////////////////////////////////////////////////////////////////////////////
   4 //
   5 // class AliHBTPositionRandomizer
   6 //
   7 // These class randomizes particle vertex positions
   8 // Piotr.Skowronski@cern.ch
   9 //
  10 ////////////////////////////////////////////////////////////////////////////////
  11
  12 #include <TRandom.h>
  13 #include "AliHBTRun.h"
  14 #include "AliHBTEvent.h"
  15 #include "AliHBTParticle.h"
  16
  17
  18 ClassImp(AliHBTPositionRandomizer)
  19
  20 /*********************************************************************/
  21
  22 AliHBTPositionRandomizer::AliHBTPositionRandomizer():
  23  fReader(0x0),
  24  fRandomizer(0x0),
  25  fModel(0),
  26  fAddToExistingPos(kFALSE),
  27  fOnlyParticlesFromVertex(kFALSE),
  28  fVX(0.0),
  29  fVY(0.0),
  30  fVZ(0.0)
  31 {
  32 //constructor
  33 }
  34 /*********************************************************************/
  35
  36 AliHBTPositionRandomizer::AliHBTPositionRandomizer(AliHBTReader* reader):
  37  fReader(reader),
  38  fRandomizer(new AliHBTRndmGaussBall(8.0)),
  39  fModel(0),
  40  fAddToExistingPos(kFALSE),
  41  fOnlyParticlesFromVertex(kFALSE),
  42  fVX(0.0),
  43  fVY(0.0),
  44  fVZ(0.0)
  45 {
  46 //constructor
  47 }
  48 /*********************************************************************/
  49
  50 AliHBTPositionRandomizer::AliHBTPositionRandomizer(const AliHBTPositionRandomizer& in):
  51  AliHBTReader(in),
  52  fReader(),
  53  fRandomizer(0x0),
  54  fModel(0),
  55  fAddToExistingPos(kFALSE),
  56  fOnlyParticlesFromVertex(kFALSE),
  57  fVX(0.0),
  58  fVY(0.0),
  59  fVZ(0.0)
  60 {
  61   //cpy constructor
  62   in.Copy(*this);
  63 }
  64 /*********************************************************************/
  65 AliHBTPositionRandomizer::~AliHBTPositionRandomizer()
  66 {
  67   //dtor
  68   delete fReader;
  69   delete fRandomizer;
  70 }
  71 /*********************************************************************/
  72 const AliHBTPositionRandomizer& AliHBTPositionRandomizer::operator=(const AliHBTPositionRandomizer& in)
  73 {
  74   //assigment operator
  75   in.Copy(*this);
  76   return *this;
  77 }
  78 /*********************************************************************/
  79
  80 AliHBTEvent* AliHBTPositionRandomizer::GetParticleEvent()
  81 {
  82  // gets from fReader and randomizes current particle event
  83  if (fReader == 0x0) return 0x0;
  84  AliHBTEvent *e =  fReader->GetParticleEvent();
  85  if (e->IsRandomized() == kFALSE) Randomize(e);
  86  return e;
  87 }
  88 /*********************************************************************/
  89
  90 AliHBTEvent* AliHBTPositionRandomizer::GetTrackEvent()
  91 {
  92  // gets from fReader and randomizes current track event
  93  if (fReader == 0x0) return 0x0;
  94  AliHBTEvent *e =  fReader->GetTrackEvent();
  95  if (e->IsRandomized() == kFALSE) Randomize(e);
  96  return e;
  97 }
  98 /*********************************************************************/
  99
 100 Int_t AliHBTPositionRandomizer::Read(AliHBTRun* particles, AliHBTRun *tracks)
 101 {
 102   //Reads all available events and randomizes them
 103   if (fReader == 0x0) return 1;
 104   Info("Randomize(AliHBTRun*)","");
 105   Int_t err = fReader->Read(particles,tracks);
 106   if (err) return err;
 107   Randomize(particles);
 108   return 0;
 109 }
 110 /*********************************************************************/
 111
 112 AliHBTEvent* AliHBTPositionRandomizer::GetParticleEvent(Int_t n)
 113 {
 114 //returns event n
 115  if (fReader == 0x0) return 0x0;
 116  AliHBTEvent *e =  fReader->GetParticleEvent(n);
 117  if (e->IsRandomized() == kFALSE) Randomize(e);
 118  return e;
 119 }
 120
 121 /*********************************************************************/
 122
 123 void AliHBTPositionRandomizer::Randomize(AliHBTRun* run) const
 124 {
 125 // randomizes postions of all particles in the run
 126   if (run == 0x0) return;
 127   Info("Randomize(AliHBTRun*)","");
 128   for (Int_t i = 0; i < run->GetNumberOfEvents(); i++)
 129    {
 130      Randomize(run->GetEvent(i));
 131    }
 132 }
 133 /*********************************************************************/
 134 void AliHBTPositionRandomizer::Randomize(AliHBTEvent* event) const
 135 {
 136 // randomizes postions of all particles in the event
 137   static const Double_t kfmtocm = 1.e-13;
 138   Info("Randomize(AliHBTEvent*)","");
 139   if (event == 0x0) return;
 140
 141   for (Int_t i = 0; i < event->GetNumberOfParticles(); i++)
 142    {
 143      AliHBTParticle* p = event->GetParticle(i);
 144      Double_t x,y,z,t=0.0;
 145      fRandomizer->Randomize(x,y,z,p);
 146      p->SetProductionVertex(x*kfmtocm,y*kfmtocm,z*kfmtocm,t*kfmtocm);
 147    }
 148   event->SetRandomized();
 149 }
 150 /*********************************************************************/
 151
 152 void AliHBTPositionRandomizer::SetGaussianBall(Double_t r)
 153 {
 154  //Sets Gaussian Ball Model
 155   SetGaussianBall(r,r,r);
 156 }
 157 /*********************************************************************/
 158
 159 void AliHBTPositionRandomizer::SetGaussianBall(Double_t rx, Double_t ry, Double_t rz)
 160 {
 161  //Sets Gaussian Ball Model
 162   delete fRandomizer;
 163   fRandomizer = new AliHBTRndmGaussBall(rx,ry,rz);
 164 }
 165 /*********************************************************************/
 166
 167 void AliHBTPositionRandomizer::SetCyllinderSurface(Double_t r, Double_t l)
 168 {
 169  //Sets Cylinder Surface Model
 170   delete fRandomizer;
 171   fRandomizer = new  AliHBTRndmCyllSurf(r,l);
 172 }
 173 /*********************************************************************/
 174
 175 void AliHBTPositionRandomizer::SetEventVertex(Double_t x, Double_t y,Double_t z)
 176 {
 177 //sets event vertex position
 178   fVX = x;
 179   fVY = y;
 180   fVZ = z;
 181 }
 182 /*********************************************************************/
 183 //_____________________________________________________________________
 184 ///////////////////////////////////////////////////////////////////////
 185 //                                                                   //
 186 //  class AliHBTRndmGaussBall                                        //
 187 //                                                                   //
 188 ///////////////////////////////////////////////////////////////////////
 189
 190 AliHBTRndmGaussBall::AliHBTRndmGaussBall():
 191  fRx(0.0),
 192  fRy(0.0),
 193  fRz(0.0)
 194 {
 195   //constructor
 196 }
 197 /*********************************************************************/
 198
 199 AliHBTRndmGaussBall::AliHBTRndmGaussBall(Float_t r):
 200  fRx(r),
 201  fRy(r),
 202  fRz(r)
 203 {
 204   //constructor
 205 }
 206 /*********************************************************************/
 207
 208 AliHBTRndmGaussBall::AliHBTRndmGaussBall(Float_t rx, Float_t ry, Float_t rz):
 209  fRx(rx),
 210  fRy(ry),
 211  fRz(rz)
 212 {
 213   //constructor
 214 }
 215 /*********************************************************************/
 216
 217 void AliHBTRndmGaussBall::Randomize(Double_t& x,Double_t& y,Double_t&z, AliHBTParticle*/*particle*/) const
 218 {
 219 //randomizez gauss for each coordinate separately
 220   x = gRandom->Gaus(0.0,fRx);
 221   y = gRandom->Gaus(0.0,fRy);
 222   z = gRandom->Gaus(0.0,fRz);
 223 }
 224 /*********************************************************************/
 225 //_____________________________________________________________________
 226 ///////////////////////////////////////////////////////////////////////
 227 //                                                                   //
 228 //  class AliHBTRndmGaussBall                                        //
 229 //                                                                   //
 230 ///////////////////////////////////////////////////////////////////////
 231
 232 void AliHBTRndmCyllSurf::Randomize(Double_t& x,Double_t& y,Double_t&z, AliHBTParticle* particle) const
 233 {
 234 //Randomizes x,y,z
 235    Double_t r = fR + gRandom->Gaus(0.0, 1.0);
 236    Double_t sf = r/particle->Pt();//scaling factor for position transformation ->
 237                              //we move direction of string momentum but legth defined by r
 238    x = sf*particle->Px();
 239    y = sf*particle->Py();
 240    z = gRandom->Uniform(-fL,fL);
 241 }