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::GenerateN(Int_t ntimes)
 220 {
 221 //
 222 //  Run generator n times
 223 //    Used by AliGenCocktail for adding extra signals in proportion to
 224 //    multiplicity/centrality
 225 //  By default generates one AliGenHeader for each call to Generate()
 226 //   Can be overloaded (e.g. AliGenBox and AliGenParam) to consolidate headers
 227 //
 228   for (Int_t i=0; i < ntimes; i++) {
 229     Generate();
 230   }
 231 }
 232 //_______________________________________________________________________
 233 void AliGenerator::SetOrigin(Float_t ox, Float_t oy, Float_t oz)
 234 {
 235   //
 236   // Set the vertex for the generated tracks
 237   //
 238   fOrigin[0]=ox;
 239   fOrigin[1]=oy;
 240   fOrigin[2]=oz;
 241 }
 242
 243 //_______________________________________________________________________
 244 void AliGenerator::SetOrigin(const TLorentzVector &o)
 245 {
 246   //
 247   // Set the vertex for the generated tracks
 248   //
 249   fOrigin[0]=o[0];
 250   fOrigin[1]=o[1];
 251   fOrigin[2]=o[2];
 252 }
 253
 254 //_______________________________________________________________________
 255 void AliGenerator::SetSigma(Float_t sx, Float_t sy, Float_t sz)
 256 {
 257   //
 258   // Set the spread of the vertex
 259   //
 260   fOsigma[0]=sx;
 261   fOsigma[1]=sy;
 262   fOsigma[2]=sz;
 263 }
 264
 265 //_______________________________________________________________________
 266 void AliGenerator::SetMomentumRange(Float_t pmin, Float_t pmax)
 267 {
 268   //
 269   // Set the momentum range for the generated particles
 270   //
 271   fPMin = pmin;
 272   fPMax = pmax;
 273   SetBit(kMomentumRange);
 274 }
 275
 276 //_______________________________________________________________________
 277 void AliGenerator::SetPtRange(Float_t ptmin, Float_t ptmax)
 278 {
 279   //
 280   // Set the Pt range for the generated particles
 281   //
 282   fPtMin = ptmin;
 283   fPtMax = ptmax;
 284   SetBit(kPtRange);
 285 }
 286
 287 //_______________________________________________________________________
 288 void AliGenerator::SetPhiRange(Float_t phimin, Float_t phimax)
 289 {
 290   //
 291   // Set the Phi range for the generated particles
 292   //
 293   fPhiMin = TMath::Pi()*phimin/180;
 294   fPhiMax = TMath::Pi()*phimax/180;
 295   SetBit(kPhiRange);
 296 }
 297
 298 //_______________________________________________________________________
 299 void AliGenerator::SetYRange(Float_t ymin, Float_t ymax)
 300 {
 301   //
 302   // Set the Rapidity range for the generated particles
 303   //
 304   fYMin=ymin;
 305   fYMax=ymax;
 306   SetBit(kYRange);
 307 }
 308
 309 //_______________________________________________________________________
 310 void AliGenerator::SetVRange(Float_t vxmin, Float_t vxmax,
 311                              Float_t vymin, Float_t vymax,
 312                              Float_t vzmin, Float_t vzmax)
 313 {
 314   //
 315   // Set the vertex range for the generated particles
 316   //
 317   fVMin[0]=vxmin; fVMin[1]=vymin; fVMin[2]=vzmin;
 318   fVMax[0]=vxmax; fVMax[1]=vymax; fVMax[2]=vzmax;
 319   SetBit(kVertexRange);
 320 }
 321
 322 //_______________________________________________________________________
 323 void AliGenerator::SetThetaRange(Float_t thetamin, Float_t thetamax)
 324 {
 325   //
 326   // Set the theta range for the generated particles
 327   //
 328   fThetaMin = TMath::Pi()*thetamin/180;
 329   fThetaMax = TMath::Pi()*thetamax/180;
 330   SetBit(kThetaRange);
 331 }
 332
 333 void AliGenerator::Vertex()
 334 {
 335   //
 336   // Obtain vertex for current event from external source or calculated (internal)
 337   //
 338     if (fVertexSource == kInternal) {
 339         VertexInternal();
 340     } else if (fVertexSource == kContainer) {
 341         ;
 342     } else if (fVertexSource == kExternal) {
 343         VertexExternal();
 344     }
 345 }
 346
 347 //_______________________________________________________________________
 348 void AliGenerator::VertexExternal()
 349 {
 350     //
 351     // Obtain vertex from external source (vertex generator)
 352     //
 353     TVector3 vertex = fVertexGenerator->GetVertex();
 354     fVertex[0] = vertex.X();
 355     fVertex[1] = vertex.Y();
 356     fVertex[2] = vertex.Z();
 357     fTime = 0.;
 358 }
 359
 360 //_______________________________________________________________________
 361 void AliGenerator::VertexInternal()
 362 {
 363     //
 364     // Obtain calculated vertex
 365     // Default is gaussian smearing
 366     Float_t random[6];
 367     Float_t dv[3];
 368     Int_t j;
 369     dv[2] = 1.e10;
 370     if (!TestBit(kVertexRange)) {
 371         while(TMath::Abs(dv[2]) > fCutVertexZ*fOsigma[2]) {
 372             Rndm(random,6);
 373             for (j=0; j < 3; j++) {
 374                 dv[j] = fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
 375                     TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
 376             }
 377         }
 378         for (j=0; j < 3; j++) fVertex[j] = fOrigin[j] + dv[j];
 379
 380         // In case of gaussian smearing we smear also the event/collision time
 381         Rndm(random,2);
 382         fTime = fTimeOrigin + fOsigma[2]/TMath::Ccgs()*
 383           TMath::Cos(2*random[0]*TMath::Pi())*
 384           TMath::Sqrt(-2*TMath::Log(random[1]));
 385
 386     } else {
 387         Rndm(random,3);
 388         for (j=0; j < 3; j++)
 389             fVertex[j] =  fVMin[j] + random[j] * (fVMax[j] - fVMin[j]);
 390         fTime = 0.;
 391     }
 392 }
 393
 394 //_______________________________________________________________________
 395 void  AliGenerator::PushTrack(Int_t done, Int_t parent, Int_t pdg,
 396                                Float_t *pmom, Float_t *vpos, Float_t *polar,
 397                                Float_t tof, TMCProcess mech, Int_t &ntr,
 398                                Float_t weight, Int_t is)
 399 {
 400   //
 401   // Loads one track on the stack
 402   //
 403
 404   if (fStack)
 405     fStack->PushTrack(done, parent, pdg, pmom, vpos, polar, tof,
 406                      mech, ntr, weight, is);
 407   else
 408     gAlice->GetMCApp()->PushTrack(done, parent, pdg, pmom, vpos, polar, tof,
 409                      mech, ntr, weight, is);
 410 }
 411
 412 //_______________________________________________________________________
 413 void  AliGenerator::PushTrack(Int_t done, Int_t parent, Int_t pdg,
 414                       Double_t px, Double_t py, Double_t pz, Double_t e,
 415                       Double_t vx, Double_t vy, Double_t vz, Double_t tof,
 416                       Double_t polx, Double_t poly, Double_t polz,
 417                       TMCProcess mech, Int_t &ntr, Float_t weight, Int_t is)
 418 {
 419   //
 420   // Loads one track on the stack
 421   //
 422
 423   if (fStack)
 424      fStack->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
 425                       polx, poly, polz, mech, ntr, weight, is);
 426   else
 427      gAlice->GetMCApp()->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
 428                         polx, poly, polz, mech, ntr, weight, is);
 429 }
 430
 431
 432 //_______________________________________________________________________
 433 void AliGenerator:: KeepTrack(Int_t itrack)
 434 {
 435   //
 436   // Declare a track permanent on the stack
 437   //
 438   if (fStack)
 439      fStack->KeepTrack(itrack);
 440   else
 441      gAlice->GetMCApp()->KeepTrack(itrack);
 442
 443 }
 444
 445 //_______________________________________________________________________
 446 void AliGenerator:: SetHighWaterMark(Int_t nt)
 447 {
 448   //
 449   // Internal function to set the maximum index used in the stack
 450   //
 451   if (fStack)
 452      fStack->SetHighWaterMark(nt);
 453   else
 454      gAlice->GetMCApp()->SetHighWaterMark(nt);
 455
 456 }
 457 void AliGenerator::FinishRun()
 458 {
 459     ;
 460 }