Set the seed in AliRndm
[u/mrichter/AliRoot.git] / 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 }
461
462 //_______________________________________________________________________
463 void AliGenerator::SetSeed(UInt_t seed)
464 {
465   // 
466   // function to set the seed in the random number generator used by this generator
467   //
468   GetRandom()->SetSeed(seed);
469 }