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   fStack(0),
  85   fContainer(0),
  86   fCollisionGeometry(0),
  87   fEnergyCMS(0),
  88   fAProjectile(0),
  89   fZProjectile(0),
  90   fATarget(0),
  91   fZTarget(0),
  92   fProjectile(""),
  93   fTarget("")
  94 {
  95   //
  96   // Default constructor
  97   //
  98     if (gAlice) {
  99         AliDebug(1, "AliGenerator Default Constructor");
 100         AliMC * mc = gAlice->GetMCApp();
 101         if (mc) mc->SetGenerator(this);
 102     }
 103
 104     SetThetaRange(); ResetBit(kThetaRange);
 105     SetPhiRange(); ResetBit(kPhiRange);
 106     SetMomentumRange(); ResetBit(kMomentumRange);
 107     SetPtRange(); ResetBit(kPtRange);
 108     SetYRange(); ResetBit(kYRange);
 109     SetNumberParticles();
 110     SetTrackingFlag();
 111     SetCutVertexZ();
 112
 113
 114     fOrigin[0]=fOrigin[1]=fOrigin[2]=0;
 115     fOsigma[0]=fOsigma[1]=fOsigma[2]=0;
 116     fVertex[0]=fVertex[1]=fVertex[2]=0;
 117
 118     fVMin[0]=fVMin[1]=fVMin[2]=0;
 119     fVMax[0]=fVMax[1]=fVMax[2]=10000;
 120 }
 121
 122 //_______________________________________________________________________
 123 AliGenerator::AliGenerator(Int_t npart):
 124   TNamed(),
 125   AliRndm(),
 126   fMCEvGen(0),
 127   fThetaMin(0),
 128   fThetaMax(0),
 129   fPhiMin(0),
 130   fPhiMax(0),
 131   fPMin(0),
 132   fPMax(0),
 133   fPtMin(0),
 134   fPtMax(0),
 135   fYMin(0),
 136   fYMax(0),
 137   fVMin(3),
 138   fVMax(3),
 139   fNpart(0),
 140   fParentWeight(0),
 141   fChildWeight(0),
 142   fAnalog(0),
 143   fVertexSmear(kNoSmear),
 144   fVertexSource(kInternal),
 145   fCutVertexZ(0),
 146   fPileUpTimeWindow(-1.),
 147   fTrackIt(0),
 148   fVertexGenerator(0),
 149   fOrigin(3),
 150   fOsigma(3),
 151   fVertex(3),
 152   fTimeOrigin(0.),
 153   fTime(0.),
 154   fStack(0),
 155   fContainer(0),
 156   fCollisionGeometry(0),
 157   fEnergyCMS(0),
 158   fAProjectile(0),
 159   fZProjectile(0),
 160   fATarget(0),
 161   fZTarget(0),
 162   fProjectile(""),
 163   fTarget("")
 164 {
 165   //
 166   // Standard constructor
 167   //
 168     if (gAlice) {
 169         AliDebug(1, "AliGenerator Constructor initializing number of particles");
 170         AliMC * mc = gAlice->GetMCApp();
 171         if (mc) mc->SetGenerator(this);
 172     }
 173
 174     SetThetaRange(); ResetBit(kThetaRange);
 175     SetPhiRange(); ResetBit(kPhiRange);
 176     SetMomentumRange(); ResetBit(kMomentumRange);
 177     SetPtRange(); ResetBit(kPtRange);
 178     SetYRange(); ResetBit(kYRange);
 179     SetTrackingFlag();
 180     SetCutVertexZ();
 181
 182     fOrigin[0]=fOrigin[1]=fOrigin[2]=0;
 183     fOsigma[0]=fOsigma[1]=fOsigma[2]=0;
 184     fVertex[0]=fVertex[1]=fVertex[2]=0;
 185
 186     fVMin[0]=fVMin[1]=fVMin[2]=0;
 187     fVMax[0]=fVMax[1]=fVMax[2]=10000;
 188
 189     SetNumberParticles(npart);
 190
 191     AliConfig::Instance()->Add(this);
 192 }
 193
 194 //_______________________________________________________________________
 195 AliGenerator::~AliGenerator()
 196 {
 197   //
 198   // Destructor
 199   //
 200   fOrigin.Set(0);
 201   fOsigma.Set(0);
 202   if (fMCEvGen) {
 203     delete fMCEvGen;
 204     fMCEvGen=0;
 205   }
 206 }
 207
 208 //_______________________________________________________________________
 209 void AliGenerator::Init()
 210 {
 211   //
 212   // Dummy initialisation
 213   //
 214 }
 215
 216 //_______________________________________________________________________
 217 void AliGenerator::SetOrigin(Float_t ox, Float_t oy, Float_t oz)
 218 {
 219   //
 220   // Set the vertex for the generated tracks
 221   //
 222   fOrigin[0]=ox;
 223   fOrigin[1]=oy;
 224   fOrigin[2]=oz;
 225 }
 226
 227 //_______________________________________________________________________
 228 void AliGenerator::SetOrigin(const TLorentzVector &o)
 229 {
 230   //
 231   // Set the vertex for the generated tracks
 232   //
 233   fOrigin[0]=o[0];
 234   fOrigin[1]=o[1];
 235   fOrigin[2]=o[2];
 236 }
 237
 238 //_______________________________________________________________________
 239 void AliGenerator::SetSigma(Float_t sx, Float_t sy, Float_t sz)
 240 {
 241   //
 242   // Set the spread of the vertex
 243   //
 244   fOsigma[0]=sx;
 245   fOsigma[1]=sy;
 246   fOsigma[2]=sz;
 247 }
 248
 249 //_______________________________________________________________________
 250 void AliGenerator::SetMomentumRange(Float_t pmin, Float_t pmax)
 251 {
 252   //
 253   // Set the momentum range for the generated particles
 254   //
 255   fPMin = pmin;
 256   fPMax = pmax;
 257   SetBit(kMomentumRange);
 258 }
 259
 260 //_______________________________________________________________________
 261 void AliGenerator::SetPtRange(Float_t ptmin, Float_t ptmax)
 262 {
 263   //
 264   // Set the Pt range for the generated particles
 265   //
 266   fPtMin = ptmin;
 267   fPtMax = ptmax;
 268   SetBit(kPtRange);
 269 }
 270
 271 //_______________________________________________________________________
 272 void AliGenerator::SetPhiRange(Float_t phimin, Float_t phimax)
 273 {
 274   //
 275   // Set the Phi range for the generated particles
 276   //
 277   fPhiMin = TMath::Pi()*phimin/180;
 278   fPhiMax = TMath::Pi()*phimax/180;
 279   SetBit(kPhiRange);
 280 }
 281
 282 //_______________________________________________________________________
 283 void AliGenerator::SetYRange(Float_t ymin, Float_t ymax)
 284 {
 285   //
 286   // Set the Rapidity range for the generated particles
 287   //
 288   fYMin=ymin;
 289   fYMax=ymax;
 290   SetBit(kYRange);
 291 }
 292
 293 //_______________________________________________________________________
 294 void AliGenerator::SetVRange(Float_t vxmin, Float_t vxmax,
 295                              Float_t vymin, Float_t vymax,
 296                              Float_t vzmin, Float_t vzmax)
 297 {
 298   //
 299   // Set the vertex range for the generated particles
 300   //
 301   fVMin[0]=vxmin; fVMin[1]=vymin; fVMin[2]=vzmin;
 302   fVMax[0]=vxmax; fVMax[1]=vymax; fVMax[2]=vzmax;
 303   SetBit(kVertexRange);
 304 }
 305
 306 //_______________________________________________________________________
 307 void AliGenerator::SetThetaRange(Float_t thetamin, Float_t thetamax)
 308 {
 309   //
 310   // Set the theta range for the generated particles
 311   //
 312   fThetaMin = TMath::Pi()*thetamin/180;
 313   fThetaMax = TMath::Pi()*thetamax/180;
 314   SetBit(kThetaRange);
 315 }
 316
 317 void AliGenerator::Vertex()
 318 {
 319   //
 320   // Obtain vertex for current event from external source or calculated (internal)
 321   //
 322     if (fVertexSource == kInternal) {
 323         VertexInternal();
 324     } else if (fVertexSource == kContainer) {
 325         ;
 326     } else if (fVertexSource == kExternal) {
 327         VertexExternal();
 328     }
 329 }
 330
 331 //_______________________________________________________________________
 332 void AliGenerator::VertexExternal()
 333 {
 334     //
 335     // Obtain vertex from external source (vertex generator)
 336     //
 337     TVector3 vertex = fVertexGenerator->GetVertex();
 338     fVertex[0] = vertex.X();
 339     fVertex[1] = vertex.Y();
 340     fVertex[2] = vertex.Z();
 341     fTime = 0.;
 342 }
 343
 344 //_______________________________________________________________________
 345 void AliGenerator::VertexInternal()
 346 {
 347     //
 348     // Obtain calculated vertex
 349     // Default is gaussian smearing
 350     Float_t random[6];
 351     Float_t dv[3];
 352     Int_t j;
 353     dv[2] = 1.e10;
 354     if (!TestBit(kVertexRange)) {
 355         while(TMath::Abs(dv[2]) > fCutVertexZ*fOsigma[2]) {
 356             Rndm(random,6);
 357             for (j=0; j < 3; j++) {
 358                 dv[j] = fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
 359                     TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
 360             }
 361         }
 362         for (j=0; j < 3; j++) fVertex[j] = fOrigin[j] + dv[j];
 363
 364         // In case of gaussian smearing we smear also the event/collision time
 365         Rndm(random,2);
 366         fTime = fTimeOrigin + fOsigma[2]/TMath::Ccgs()*
 367           TMath::Cos(2*random[0]*TMath::Pi())*
 368           TMath::Sqrt(-2*TMath::Log(random[1]));
 369
 370     } else {
 371         Rndm(random,3);
 372         for (j=0; j < 3; j++)
 373             fVertex[j] =  fVMin[j] + random[j] * (fVMax[j] - fVMin[j]);
 374         fTime = 0.;
 375     }
 376 }
 377
 378 //_______________________________________________________________________
 379 void  AliGenerator::PushTrack(Int_t done, Int_t parent, Int_t pdg,
 380                                Float_t *pmom, Float_t *vpos, Float_t *polar,
 381                                Float_t tof, TMCProcess mech, Int_t &ntr,
 382                                Float_t weight, Int_t is)
 383 {
 384   //
 385   // Loads one track on the stack
 386   //
 387
 388   if (fStack)
 389     fStack->PushTrack(done, parent, pdg, pmom, vpos, polar, tof,
 390                      mech, ntr, weight, is);
 391   else
 392     gAlice->GetMCApp()->PushTrack(done, parent, pdg, pmom, vpos, polar, tof,
 393                      mech, ntr, weight, is);
 394 }
 395
 396 //_______________________________________________________________________
 397 void  AliGenerator::PushTrack(Int_t done, Int_t parent, Int_t pdg,
 398                       Double_t px, Double_t py, Double_t pz, Double_t e,
 399                       Double_t vx, Double_t vy, Double_t vz, Double_t tof,
 400                       Double_t polx, Double_t poly, Double_t polz,
 401                       TMCProcess mech, Int_t &ntr, Float_t weight, Int_t is)
 402 {
 403   //
 404   // Loads one track on the stack
 405   //
 406
 407   if (fStack)
 408      fStack->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
 409                       polx, poly, polz, mech, ntr, weight, is);
 410   else
 411      gAlice->GetMCApp()->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
 412                         polx, poly, polz, mech, ntr, weight, is);
 413 }
 414
 415
 416 //_______________________________________________________________________
 417 void AliGenerator:: KeepTrack(Int_t itrack)
 418 {
 419   //
 420   // Declare a track permanent on the stack
 421   //
 422   if (fStack)
 423      fStack->KeepTrack(itrack);
 424   else
 425      gAlice->GetMCApp()->KeepTrack(itrack);
 426
 427 }
 428
 429 //_______________________________________________________________________
 430 void AliGenerator:: SetHighWaterMark(Int_t nt)
 431 {
 432   //
 433   // Internal function to set the maximum index used in the stack
 434   //
 435   if (fStack)
 436      fStack->SetHighWaterMark(nt);
 437   else
 438      gAlice->GetMCApp()->SetHighWaterMark(nt);
 439
 440 }
 441 void AliGenerator::FinishRun()
 442 {
 443     ;
 444 }