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