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