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