[u/mrichter/AliRoot.git] / STEER / AliGenerator.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

//-----------------------------------------------------------------
//    Generate the final state of the interaction as the input
//    to the MonteCarlo
//    Author: A.Morsch
//-----------------------------------------------------------------
//Begin_Html
/*
<img src="picts/AliGeneratorClass.gif">
</pre>
<br clear=left>
<font size=+2 color=red>
<p>The responsible person for this module is
<a href="mailto:andreas.morsch@cern.ch">Andreas Morsch</a>.
</font>
<pre>
*/
//End_Html
//                                                               //
///////////////////////////////////////////////////////////////////
#include <TGenerator.h>
#include <TMCProcess.h>

#include "AliLog.h"
#include "AliCollisionGeometry.h"
#include "AliConfig.h"
#include "AliGenerator.h"
#include "AliRun.h"
#include "AliStack.h"
#include "AliMC.h"
#include "AliVertexGenerator.h"

ClassImp(AliGenerator)


//_______________________________________________________________________
AliGenerator::AliGenerator():
  TNamed(),
  AliRndm(),
  fMCEvGen(0),
  fThetaMin(0),
  fThetaMax(0),
  fPhiMin(0),
  fPhiMax(0),
  fPMin(0),
  fPMax(0),
  fPtMin(0),
  fPtMax(0),
  fYMin(0),
  fYMax(0),
  fVMin(3),
  fVMax(3),
  fNpart(0),
  fParentWeight(0),
  fChildWeight(0),
  fAnalog(0),
  fVertexSmear(kNoSmear),
  fVertexSource(kInternal),
  fCutVertexZ(0),
  fPileUpTimeWindow(-1.),
  fTrackIt(0),
  fVertexGenerator(0),
  fOrigin(3),
  fOsigma(3),
  fVertex(3),
  fStack(0),
  fContainer(0),
  fCollisionGeometry(0),
  fEnergyCMS(0),
  fAProjectile(0),
  fZProjectile(0),
  fATarget(0),
  fZTarget(0),
  fProjectile(""),
  fTarget("")    
{
  //
  // Default constructor
  //
    if (gAlice) {
	AliDebug(1, "AliGenerator Default Constructor");
	AliMC * mc = gAlice->GetMCApp();
	if (mc) mc->SetGenerator(this);
    }

    SetThetaRange(); ResetBit(kThetaRange);
    SetPhiRange(); ResetBit(kPhiRange);
    SetMomentumRange(); ResetBit(kMomentumRange);
    SetPtRange(); ResetBit(kPtRange);
    SetYRange(); ResetBit(kYRange);
    SetNumberParticles();
    SetTrackingFlag();
    SetCutVertexZ();


    fOrigin[0]=fOrigin[1]=fOrigin[2]=0;
    fOsigma[0]=fOsigma[1]=fOsigma[2]=0;
    fVertex[0]=fVertex[1]=fVertex[2]=0;

    fVMin[0]=fVMin[1]=fVMin[2]=0;
    fVMax[0]=fVMax[1]=fVMax[2]=10000;
}

//_______________________________________________________________________
AliGenerator::AliGenerator(Int_t npart):
  TNamed(),
  AliRndm(),
  fMCEvGen(0),
  fThetaMin(0),
  fThetaMax(0),
  fPhiMin(0),
  fPhiMax(0),
  fPMin(0),
  fPMax(0),
  fPtMin(0),
  fPtMax(0),
  fYMin(0),
  fYMax(0),
  fVMin(3),
  fVMax(3),
  fNpart(0),
  fParentWeight(0),
  fChildWeight(0),
  fAnalog(0),
  fVertexSmear(kNoSmear),
  fVertexSource(kInternal),
  fCutVertexZ(0),
  fPileUpTimeWindow(-1.),
  fTrackIt(0),
  fVertexGenerator(0),
  fOrigin(3),
  fOsigma(3),
  fVertex(3),
  fStack(0),
  fContainer(0),
  fCollisionGeometry(0),
  fEnergyCMS(0),
  fAProjectile(0),
  fZProjectile(0),
  fATarget(0),
  fZTarget(0),
  fProjectile(""),
  fTarget("")    
{
  //
  // Standard constructor
  //
    if (gAlice) {
        AliDebug(1, "AliGenerator Constructor initializing number of particles");
	AliMC * mc = gAlice->GetMCApp();
	if (mc) mc->SetGenerator(this);
    }
    
    SetThetaRange(); ResetBit(kThetaRange);
    SetPhiRange(); ResetBit(kPhiRange);
    SetMomentumRange(); ResetBit(kMomentumRange);
    SetPtRange(); ResetBit(kPtRange);
    SetYRange(); ResetBit(kYRange);
    SetTrackingFlag();
    SetCutVertexZ();

    fOrigin[0]=fOrigin[1]=fOrigin[2]=0;
    fOsigma[0]=fOsigma[1]=fOsigma[2]=0;
    fVertex[0]=fVertex[1]=fVertex[2]=0;

    fVMin[0]=fVMin[1]=fVMin[2]=0;
    fVMax[0]=fVMax[1]=fVMax[2]=10000;

    SetNumberParticles(npart);

    AliConfig::Instance()->Add(this);
}

//_______________________________________________________________________
AliGenerator::~AliGenerator()
{
  //
  // Destructor
  //
  fOrigin.Set(0);
  fOsigma.Set(0);
  if (fMCEvGen) {
    delete fMCEvGen;
    fMCEvGen=0;
  }
}

//_______________________________________________________________________
void AliGenerator::Init()
{   
  //
  // Dummy initialisation
  //
}

//_______________________________________________________________________
void AliGenerator::SetOrigin(Float_t ox, Float_t oy, Float_t oz)
{
  //
  // Set the vertex for the generated tracks
  //
  fOrigin[0]=ox;
  fOrigin[1]=oy;
  fOrigin[2]=oz;
}

//_______________________________________________________________________
void AliGenerator::SetOrigin(const TLorentzVector &o)
{
  //
  // Set the vertex for the generated tracks
  //
  fOrigin[0]=o[0];
  fOrigin[1]=o[1];
  fOrigin[2]=o[2];
}

//_______________________________________________________________________
void AliGenerator::SetSigma(Float_t sx, Float_t sy, Float_t sz)
{
  //
  // Set the spread of the vertex
  //
  fOsigma[0]=sx;
  fOsigma[1]=sy;
  fOsigma[2]=sz;
}

//_______________________________________________________________________
void AliGenerator::SetMomentumRange(Float_t pmin, Float_t pmax)
{
  //
  // Set the momentum range for the generated particles
  //
  fPMin = pmin;
  fPMax = pmax;
  SetBit(kMomentumRange);
}

//_______________________________________________________________________
void AliGenerator::SetPtRange(Float_t ptmin, Float_t ptmax)
{
  //
  // Set the Pt range for the generated particles
  //
  fPtMin = ptmin;
  fPtMax = ptmax;
  SetBit(kPtRange);
}

//_______________________________________________________________________
void AliGenerator::SetPhiRange(Float_t phimin, Float_t phimax)
{
  //
  // Set the Phi range for the generated particles
  //
  fPhiMin = TMath::Pi()*phimin/180;
  fPhiMax = TMath::Pi()*phimax/180;
  SetBit(kPhiRange);
}

//_______________________________________________________________________
void AliGenerator::SetYRange(Float_t ymin, Float_t ymax)
{
  //
  // Set the Rapidity range for the generated particles
  //
  fYMin=ymin;
  fYMax=ymax;
  SetBit(kYRange);
}

//_______________________________________________________________________
void AliGenerator::SetVRange(Float_t vxmin, Float_t vxmax,
			     Float_t vymin, Float_t vymax,
			     Float_t vzmin, Float_t vzmax)
{
  //
  // Set the vertex range for the generated particles
  //
  fVMin[0]=vxmin; fVMin[1]=vymin; fVMin[2]=vzmin;
  fVMax[0]=vxmax; fVMax[1]=vymax; fVMax[2]=vzmax;
  SetBit(kVertexRange);
}

//_______________________________________________________________________
void AliGenerator::SetThetaRange(Float_t thetamin, Float_t thetamax)
{
  //
  // Set the theta range for the generated particles
  //
  fThetaMin = TMath::Pi()*thetamin/180;
  fThetaMax = TMath::Pi()*thetamax/180;
  SetBit(kThetaRange);
}

void AliGenerator::Vertex()
{
  //
  // Obtain vertex for current event from external source or calculated (internal)
  //
    if (fVertexSource == kInternal) {
	VertexInternal();
    } else if (fVertexSource == kContainer) {
	;
    } else if (fVertexSource == kExternal) {
	VertexExternal();
    }
}

//_______________________________________________________________________
void AliGenerator::VertexExternal()
{
    //
    // Obtain vertex from external source (vertex generator)
    //
    TVector3 vertex = fVertexGenerator->GetVertex();
    fVertex[0] = vertex.X();
    fVertex[1] = vertex.Y();
    fVertex[2] = vertex.Z();
}

//_______________________________________________________________________
void AliGenerator::VertexInternal()
{
    // 
    // Obtain calculated vertex 
    // Default is gaussian smearing
    Float_t random[6];
    Float_t dv[3];
    Int_t j;
    dv[2] = 1.e10;
    if (!TestBit(kVertexRange)) {
	while(TMath::Abs(dv[2]) > fCutVertexZ*fOsigma[2]) {
	    Rndm(random,6);
	    for (j=0; j < 3; j++) {
		dv[j] = fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
		    TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
	    }
	}
	for (j=0; j < 3; j++) fVertex[j] = fOrigin[j] + dv[j];
    } else {
	Rndm(random,3);
	for (j=0; j < 3; j++)
	    fVertex[j] =  fVMin[j] + random[j] * (fVMax[j] - fVMin[j]);
    }
}

//_______________________________________________________________________
void  AliGenerator::PushTrack(Int_t done, Int_t parent, Int_t pdg,
                               Float_t *pmom, Float_t *vpos, Float_t *polar,
                               Float_t tof, TMCProcess mech, Int_t &ntr,
                               Float_t weight, Int_t is)
{
  //
  // Loads one track on the stack
  //
    
  if (fStack)
    fStack->PushTrack(done, parent, pdg, pmom, vpos, polar, tof,
                     mech, ntr, weight, is);
  else 
    gAlice->GetMCApp()->PushTrack(done, parent, pdg, pmom, vpos, polar, tof,
                     mech, ntr, weight, is);
}

//_______________________________________________________________________
void  AliGenerator::PushTrack(Int_t done, Int_t parent, Int_t pdg,
                      Double_t px, Double_t py, Double_t pz, Double_t e,
                      Double_t vx, Double_t vy, Double_t vz, Double_t tof,
                      Double_t polx, Double_t poly, Double_t polz,
                      TMCProcess mech, Int_t &ntr, Float_t weight, Int_t is)
{
  //
  // Loads one track on the stack
  //
  
  if (fStack)
     fStack->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
                      polx, poly, polz, mech, ntr, weight, is);
  else 
     gAlice->GetMCApp()->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
                        polx, poly, polz, mech, ntr, weight, is);
}


//_______________________________________________________________________
void AliGenerator:: KeepTrack(Int_t itrack)
{
  //
  // Declare a track permanent on the stack
  //
  if (fStack)
     fStack->KeepTrack(itrack);
  else 
     gAlice->GetMCApp()->KeepTrack(itrack);
   
}

//_______________________________________________________________________
void AliGenerator:: SetHighWaterMark(Int_t nt)
{
  //
  // Internal function to set the maximum index used in the stack
  //
  if (fStack)
     fStack->SetHighWaterMark(nt);
  else 
     gAlice->GetMCApp()->SetHighWaterMark(nt);
   
}
void AliGenerator::FinishRun()
{
    ;
}
Commit	Line	Data
	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(2random[2j]TMath::Pi())*
	354	TMath::Sqrt(-2TMath::Log(random[2j+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	}