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