STEER/STEER/AliGenerator.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 //-----------------------------------------------------------------
  19 //    Generate the final state of the interaction as the input
  20 //    to the MonteCarlo
  21 //    Author: A.Morsch
  22 //-----------------------------------------------------------------
  23 //Begin_Html
  24 /*
  25 <img src="picts/AliGeneratorClass.gif">
  26 </pre>
  27 <br clear=left>
  28 <font size=+2 color=red>
  29 <p>The responsible person for this module is
  30 <a href="mailto:andreas.morsch@cern.ch">Andreas Morsch</a>.
  31 </font>
  32 <pre>
  33 */
  34 //End_Html
  35 //                                                               //
  36 ///////////////////////////////////////////////////////////////////
  37 #include <TGenerator.h>
  38 #include <TMCProcess.h>
  39
  40 #include "AliLog.h"
  41 #include "AliCollisionGeometry.h"
  42 #include "AliConfig.h"
  43 #include "AliGenerator.h"
  44 #include "AliRun.h"
  45 #include "AliStack.h"
  46 #include "AliMC.h"
  47 #include "AliVertexGenerator.h"
  48
  49 ClassImp(AliGenerator)
  50
  51
  52 //_______________________________________________________________________
  53 AliGenerator::AliGenerator():
  54   TNamed(),
  55   AliRndm(),
  56   fMCEvGen(0),
  57   fThetaMin(0),
  58   fThetaMax(0),
  59   fPhiMin(0),
  60   fPhiMax(0),
  61   fPMin(0),
  62   fPMax(0),
  63   fPtMin(0),
  64   fPtMax(0),
  65   fYMin(0),
  66   fYMax(0),
  67   fVMin(3),
  68   fVMax(3),
  69   fNpart(0),
  70   fParentWeight(0),
  71   fChildWeight(0),
  72   fAnalog(0),
  73   fVertexSmear(kNoSmear),
  74   fVertexSource(kInternal),
  75   fCutVertexZ(0),
  76   fPileUpTimeWindow(-1.),
  77   fTrackIt(0),
  78   fVertexGenerator(0),
  79   fOrigin(3),
  80   fOsigma(3),
  81   fVertex(3),
  82   fTimeOrigin(0.),
  83   fTime(0.),
  84   fEvPlane(0),
  85   fStack(0),
  86   fContainer(0),
  87   fCollisionGeometry(0),
  88   fEnergyCMS(0),
  89   fAProjectile(0),
  90   fZProjectile(0),
  91   fATarget(0),
  92   fZTarget(0),
  93   fProjectile(""),
  94   fTarget("")
  95 {
  96   //
  97   // Default constructor
  98   //
  99     if (gAlice) {
 100         AliDebug(1, "AliGenerator Default Constructor");
 101         AliMC * mc = gAlice->GetMCApp();
 102         if (mc) mc->SetGenerator(this);
 103     }
 104
 105     SetThetaRange(); ResetBit(kThetaRange);
 106     SetPhiRange(); ResetBit(kPhiRange);
 107     SetMomentumRange(); ResetBit(kMomentumRange);
 108     SetPtRange(); ResetBit(kPtRange);
 109     SetYRange(); ResetBit(kYRange);
 110     SetNumberParticles();
 111     SetTrackingFlag();
 112     SetCutVertexZ();
 113
 114
 115     fOrigin[0]=fOrigin[1]=fOrigin[2]=0;
 116     fOsigma[0]=fOsigma[1]=fOsigma[2]=0;
 117     fVertex[0]=fVertex[1]=fVertex[2]=0;
 118
 119     fVMin[0]=fVMin[1]=fVMin[2]=0;
 120     fVMax[0]=fVMax[1]=fVMax[2]=10000;
 121 }
 122
 123 //_______________________________________________________________________
 124 AliGenerator::AliGenerator(Int_t npart):
 125   TNamed(),
 126   AliRndm(),
 127   fMCEvGen(0),
 128   fThetaMin(0),
 129   fThetaMax(0),
 130   fPhiMin(0),
 131   fPhiMax(0),
 132   fPMin(0),
 133   fPMax(0),
 134   fPtMin(0),
 135   fPtMax(0),
 136   fYMin(0),
 137   fYMax(0),
 138   fVMin(3),
 139   fVMax(3),
 140   fNpart(0),
 141   fParentWeight(0),
 142   fChildWeight(0),
 143   fAnalog(0),
 144   fVertexSmear(kNoSmear),
 145   fVertexSource(kInternal),
 146   fCutVertexZ(0),
 147   fPileUpTimeWindow(-1.),
 148   fTrackIt(0),
 149   fVertexGenerator(0),
 150   fOrigin(3),
 151   fOsigma(3),
 152   fVertex(3),
 153   fTimeOrigin(0.),
 154   fTime(0.),
 155   fEvPlane(0),
 156   fStack(0),
 157   fContainer(0),
 158   fCollisionGeometry(0),
 159   fEnergyCMS(0),
 160   fAProjectile(0),
 161   fZProjectile(0),
 162   fATarget(0),
 163   fZTarget(0),
 164   fProjectile(""),
 165   fTarget("")
 166 {
 167   //
 168   // Standard constructor
 169   //
 170     if (gAlice) {
 171         AliDebug(1, "AliGenerator Constructor initializing number of particles");
 172         AliMC * mc = gAlice->GetMCApp();
 173         if (mc) mc->SetGenerator(this);
 174     }
 175
 176     SetThetaRange(); ResetBit(kThetaRange);
 177     SetPhiRange(); ResetBit(kPhiRange);
 178     SetMomentumRange(); ResetBit(kMomentumRange);
 179     SetPtRange(); ResetBit(kPtRange);
 180     SetYRange(); ResetBit(kYRange);
 181     SetTrackingFlag();
 182     SetCutVertexZ();
 183
 184     fOrigin[0]=fOrigin[1]=fOrigin[2]=0;
 185     fOsigma[0]=fOsigma[1]=fOsigma[2]=0;
 186     fVertex[0]=fVertex[1]=fVertex[2]=0;
 187
 188     fVMin[0]=fVMin[1]=fVMin[2]=0;
 189     fVMax[0]=fVMax[1]=fVMax[2]=10000;
 190
 191     SetNumberParticles(npart);
 192
 193     AliConfig::Instance()->Add(this);
 194 }
 195
 196 //_______________________________________________________________________
 197 AliGenerator::~AliGenerator()
 198 {
 199   //
 200   // Destructor
 201   //
 202   fOrigin.Set(0);
 203   fOsigma.Set(0);
 204   if (fMCEvGen) {
 205     delete fMCEvGen;
 206     fMCEvGen=0;
 207   }
 208 }
 209
 210 //_______________________________________________________________________
 211 void AliGenerator::Init()
 212 {
 213   //
 214   // Dummy initialisation
 215   //
 216 }
 217
 218 //_______________________________________________________________________
 219 void AliGenerator::SetOrigin(Float_t ox, Float_t oy, Float_t oz)
 220 {
 221   //
 222   // Set the vertex for the generated tracks
 223   //
 224   fOrigin[0]=ox;
 225   fOrigin[1]=oy;
 226   fOrigin[2]=oz;
 227 }
 228
 229 //_______________________________________________________________________
 230 void AliGenerator::SetOrigin(const TLorentzVector &o)
 231 {
 232   //
 233   // Set the vertex for the generated tracks
 234   //
 235   fOrigin[0]=o[0];
 236   fOrigin[1]=o[1];
 237   fOrigin[2]=o[2];
 238 }
 239
 240 //_______________________________________________________________________
 241 void AliGenerator::SetSigma(Float_t sx, Float_t sy, Float_t sz)
 242 {
 243   //
 244   // Set the spread of the vertex
 245   //
 246   fOsigma[0]=sx;
 247   fOsigma[1]=sy;
 248   fOsigma[2]=sz;
 249 }
 250
 251 //_______________________________________________________________________
 252 void AliGenerator::SetMomentumRange(Float_t pmin, Float_t pmax)
 253 {
 254   //
 255   // Set the momentum range for the generated particles
 256   //
 257   fPMin = pmin;
 258   fPMax = pmax;
 259   SetBit(kMomentumRange);
 260 }
 261
 262 //_______________________________________________________________________
 263 void AliGenerator::SetPtRange(Float_t ptmin, Float_t ptmax)
 264 {
 265   //
 266   // Set the Pt range for the generated particles
 267   //
 268   fPtMin = ptmin;
 269   fPtMax = ptmax;
 270   SetBit(kPtRange);
 271 }
 272
 273 //_______________________________________________________________________
 274 void AliGenerator::SetPhiRange(Float_t phimin, Float_t phimax)
 275 {
 276   //
 277   // Set the Phi range for the generated particles
 278   //
 279   fPhiMin = TMath::Pi()*phimin/180;
 280   fPhiMax = TMath::Pi()*phimax/180;
 281   SetBit(kPhiRange);
 282 }
 283
 284 //_______________________________________________________________________
 285 void AliGenerator::SetYRange(Float_t ymin, Float_t ymax)
 286 {
 287   //
 288   // Set the Rapidity range for the generated particles
 289   //
 290   fYMin=ymin;
 291   fYMax=ymax;
 292   SetBit(kYRange);
 293 }
 294
 295 //_______________________________________________________________________
 296 void AliGenerator::SetVRange(Float_t vxmin, Float_t vxmax,
 297                              Float_t vymin, Float_t vymax,
 298                              Float_t vzmin, Float_t vzmax)
 299 {
 300   //
 301   // Set the vertex range for the generated particles
 302   //
 303   fVMin[0]=vxmin; fVMin[1]=vymin; fVMin[2]=vzmin;
 304   fVMax[0]=vxmax; fVMax[1]=vymax; fVMax[2]=vzmax;
 305   SetBit(kVertexRange);
 306 }
 307
 308 //_______________________________________________________________________
 309 void AliGenerator::SetThetaRange(Float_t thetamin, Float_t thetamax)
 310 {
 311   //
 312   // Set the theta range for the generated particles
 313   //
 314   fThetaMin = TMath::Pi()*thetamin/180;
 315   fThetaMax = TMath::Pi()*thetamax/180;
 316   SetBit(kThetaRange);
 317 }
 318
 319 void AliGenerator::Vertex()
 320 {
 321   //
 322   // Obtain vertex for current event from external source or calculated (internal)
 323   //
 324     if (fVertexSource == kInternal) {
 325         VertexInternal();
 326     } else if (fVertexSource == kContainer) {
 327         ;
 328     } else if (fVertexSource == kExternal) {
 329         VertexExternal();
 330     }
 331 }
 332
 333 //_______________________________________________________________________
 334 void AliGenerator::VertexExternal()
 335 {
 336     //
 337     // Obtain vertex from external source (vertex generator)
 338     //
 339     TVector3 vertex = fVertexGenerator->GetVertex();
 340     fVertex[0] = vertex.X();
 341     fVertex[1] = vertex.Y();
 342     fVertex[2] = vertex.Z();
 343     fTime = 0.;
 344 }
 345
 346 //_______________________________________________________________________
 347 void AliGenerator::VertexInternal()
 348 {
 349     //
 350     // Obtain calculated vertex
 351     // Default is gaussian smearing
 352     Float_t random[6];
 353     Float_t dv[3];
 354     Int_t j;
 355     dv[2] = 1.e10;
 356     if (!TestBit(kVertexRange)) {
 357         while(TMath::Abs(dv[2]) > fCutVertexZ*fOsigma[2]) {
 358             Rndm(random,6);
 359             for (j=0; j < 3; j++) {
 360                 dv[j] = fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
 361                     TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
 362             }
 363         }
 364         for (j=0; j < 3; j++) fVertex[j] = fOrigin[j] + dv[j];
 365
 366         // In case of gaussian smearing we smear also the event/collision time
 367         Rndm(random,2);
 368         fTime = fTimeOrigin + fOsigma[2]/TMath::Ccgs()*
 369           TMath::Cos(2*random[0]*TMath::Pi())*
 370           TMath::Sqrt(-2*TMath::Log(random[1]));
 371
 372     } else {
 373         Rndm(random,3);
 374         for (j=0; j < 3; j++)
 375             fVertex[j] =  fVMin[j] + random[j] * (fVMax[j] - fVMin[j]);
 376         fTime = 0.;
 377     }
 378 }
 379
 380 //_______________________________________________________________________
 381 void  AliGenerator::PushTrack(Int_t done, Int_t parent, Int_t pdg,
 382                                Float_t *pmom, Float_t *vpos, Float_t *polar,
 383                                Float_t tof, TMCProcess mech, Int_t &ntr,
 384                                Float_t weight, Int_t is)
 385 {
 386   //
 387   // Loads one track on the stack
 388   //
 389
 390   if (fStack)
 391     fStack->PushTrack(done, parent, pdg, pmom, vpos, polar, tof,
 392                      mech, ntr, weight, is);
 393   else
 394     gAlice->GetMCApp()->PushTrack(done, parent, pdg, pmom, vpos, polar, tof,
 395                      mech, ntr, weight, is);
 396 }
 397
 398 //_______________________________________________________________________
 399 void  AliGenerator::PushTrack(Int_t done, Int_t parent, Int_t pdg,
 400                       Double_t px, Double_t py, Double_t pz, Double_t e,
 401                       Double_t vx, Double_t vy, Double_t vz, Double_t tof,
 402                       Double_t polx, Double_t poly, Double_t polz,
 403                       TMCProcess mech, Int_t &ntr, Float_t weight, Int_t is)
 404 {
 405   //
 406   // Loads one track on the stack
 407   //
 408
 409   if (fStack)
 410      fStack->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
 411                       polx, poly, polz, mech, ntr, weight, is);
 412   else
 413      gAlice->GetMCApp()->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
 414                         polx, poly, polz, mech, ntr, weight, is);
 415 }
 416
 417
 418 //_______________________________________________________________________
 419 void AliGenerator:: KeepTrack(Int_t itrack)
 420 {
 421   //
 422   // Declare a track permanent on the stack
 423   //
 424   if (fStack)
 425      fStack->KeepTrack(itrack);
 426   else
 427      gAlice->GetMCApp()->KeepTrack(itrack);
 428
 429 }
 430
 431 //_______________________________________________________________________
 432 void AliGenerator:: SetHighWaterMark(Int_t nt)
 433 {
 434   //
 435   // Internal function to set the maximum index used in the stack
 436   //
 437   if (fStack)
 438      fStack->SetHighWaterMark(nt);
 439   else
 440      gAlice->GetMCApp()->SetHighWaterMark(nt);
 441
 442 }
 443 void AliGenerator::FinishRun()
 444 {
 445     ;
 446 }