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