[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 "AliCollisionGeometry.h"
#include "AliConfig.h"
#include "AliGenerator.h"
#include "AliRun.h"
#include "AliStack.h"

ClassImp(AliGenerator)


//_______________________________________________________________________
AliGenerator::AliGenerator():
  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),
  fTrackIt(0),
  fOrigin(3),
  fOsigma(3),
  fVertex(3),
  fStack(0),
  fCollisionGeometry(0)
{
  //
  // Default constructor
  //
    if (gAlice) {
	if (gAlice->GetDebug()>0)
	    printf("\n AliGenerator Default Constructor\n\n");
	gAlice->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):
  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),
  fTrackIt(0),
  fOrigin(3),
  fOsigma(3),
  fVertex(3),
  fStack(0),
  fCollisionGeometry(0)
{
  //
  // Standard constructor
  //
    if (gAlice) {
	if (gAlice->GetDebug()>0)
	    printf("\n AliGenerator Constructor initializing number of particles \n\n");
	gAlice->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(const AliGenerator &gen): 
  TNamed(gen),
  AliRndm(gen),
  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),
  fTrackIt(0),
  fOrigin(3),
  fOsigma(3),
  fVertex(3),
  fStack(0)
{
  //
  // Copy constructor
  //
  gen.Copy(*this);
}

//_______________________________________________________________________
AliGenerator & AliGenerator::operator=(const AliGenerator &gen)
{
  //
  // Assignment operator
  //
  gen.Copy(*this);
  return (*this);
}

//_______________________________________________________________________
void AliGenerator::Copy(AliGenerator &/* gen */) const
{
  //
  // Copy *this onto gen
  //
  Fatal("Copy","Not implemented!\n");
}

//_______________________________________________________________________
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()
{
    // Dummy !!!!!!
    // Obtain vertex from external source 
    //
    // Should be something like fVertex = gAlice->GetVertex()
    
    fVertex[0]=fVertex[1]=fVertex[2]=0;  
}

//_______________________________________________________________________
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->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->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->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->SetHighWaterMark(nt);
   
}
void AliGenerator::FinishRun()
{
    ;
}
Commit	Line	Data
4c039060	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
acd84897	16	/* $Id$ */
4c039060	17
5d8718b8	18	//-----------------------------------------------------------------
	19	// Generate the final state of the interaction as the input
	20	// to the MonteCarlo
	21	// Author: A.Morsch
	22	//-----------------------------------------------------------------
fe4da5cc	23	//Begin_Html
fe4da5cc	24	/*
1439f98e	25	<img src="picts/AliGeneratorClass.gif">
fe4da5cc	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	///////////////////////////////////////////////////////////////////
116cbefd	37	#include <TGenerator.h>
fe4da5cc	38
116cbefd	39	#include "AliCollisionGeometry.h"
e2afb3b6	40	#include "AliConfig.h"
fe4da5cc	41	#include "AliGenerator.h"
fe4da5cc	42	#include "AliRun.h"
69a313ec	43	#include "AliStack.h"
69a313ec	44
fe4da5cc	45	ClassImp(AliGenerator)
fe4da5cc	46
fe4da5cc	47
e2afb3b6	48	//_______________________________________________________________________
e2afb3b6	49	AliGenerator::AliGenerator():
f559aa82	50	fMCEvGen(0),
e2afb3b6	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),
0b910a04	68	fVertexSource(kInternal),
e2afb3b6	69	fCutVertexZ(0),
	70	fTrackIt(0),
	71	fOrigin(3),
	72	fOsigma(3),
	73	fVertex(3),
2c5b3727	74	fStack(0),
2c5b3727	75	fCollisionGeometry(0)
fe4da5cc	76	{
aee8290b	77	//
	78	// Default constructor
	79	//
f98e49f0	80	if (gAlice) {
	81	if (gAlice->GetDebug()>0)
	82	printf("\n AliGenerator Default Constructor\n\n");
	83	gAlice->SetGenerator(this);
	84	}
	85
de6d59e3	86	SetThetaRange(); ResetBit(kThetaRange);
	87	SetPhiRange(); ResetBit(kPhiRange);
	88	SetMomentumRange(); ResetBit(kMomentumRange);
	89	SetPtRange(); ResetBit(kPtRange);
	90	SetYRange(); ResetBit(kYRange);
fe4da5cc	91	SetNumberParticles();
4a3ba9d2	92	SetTrackingFlag();
f98e49f0	93	SetCutVertexZ();
f98e49f0	94
de6d59e3	95
fe4da5cc	96	fOrigin[0]=fOrigin[1]=fOrigin[2]=0;
fe4da5cc	97	fOsigma[0]=fOsigma[1]=fOsigma[2]=0;
f89cabfe	98	fVertex[0]=fVertex[1]=fVertex[2]=0;
f89cabfe	99
de6d59e3	100	fVMin[0]=fVMin[1]=fVMin[2]=0;
de6d59e3	101	fVMax[0]=fVMax[1]=fVMax[2]=10000;
fe4da5cc	102	}
fe4da5cc	103
e2afb3b6	104	//_______________________________________________________________________
e2afb3b6	105	AliGenerator::AliGenerator(Int_t npart):
f559aa82	106	fMCEvGen(0),
e2afb3b6	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),
0b910a04	124	fVertexSource(kInternal),
e2afb3b6	125	fCutVertexZ(0),
	126	fTrackIt(0),
	127	fOrigin(3),
	128	fOsigma(3),
	129	fVertex(3),
2c5b3727	130	fStack(0),
2c5b3727	131	fCollisionGeometry(0)
fe4da5cc	132	{
aee8290b	133	//
	134	// Standard constructor
	135	//
f98e49f0	136	if (gAlice) {
	137	if (gAlice->GetDebug()>0)
	138	printf("\n AliGenerator Constructor initializing number of particles \n\n");
	139	gAlice->SetGenerator(this);
	140	}
	141
de6d59e3	142	SetThetaRange(); ResetBit(kThetaRange);
	143	SetPhiRange(); ResetBit(kPhiRange);
	144	SetMomentumRange(); ResetBit(kMomentumRange);
	145	SetPtRange(); ResetBit(kPtRange);
	146	SetYRange(); ResetBit(kYRange);
4a3ba9d2	147	SetTrackingFlag();
f98e49f0	148	SetCutVertexZ();
de6d59e3	149
fe4da5cc	150	fOrigin[0]=fOrigin[1]=fOrigin[2]=0;
fe4da5cc	151	fOsigma[0]=fOsigma[1]=fOsigma[2]=0;
f89cabfe	152	fVertex[0]=fVertex[1]=fVertex[2]=0;
f89cabfe	153
fe4da5cc	154	fVMin[0]=fVMin[1]=fVMin[2]=0;
fe4da5cc	155	fVMax[0]=fVMax[1]=fVMax[2]=10000;
de6d59e3	156
de6d59e3	157	SetNumberParticles(npart);
9e1a0ddb	158
69a313ec	159	AliConfig::Instance()->Add(this);
fe4da5cc	160	}
fe4da5cc	161
e2afb3b6	162	//_______________________________________________________________________
	163	AliGenerator::AliGenerator(const AliGenerator &gen):
	164	TNamed(gen),
	165	AliRndm(gen),
f559aa82	166	fMCEvGen(0),
e2afb3b6	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),
0b910a04	184	fVertexSource(kInternal),
e2afb3b6	185	fCutVertexZ(0),
	186	fTrackIt(0),
	187	fOrigin(3),
	188	fOsigma(3),
	189	fVertex(3),
e2afb3b6	190	fStack(0)
aee8290b	191	{
	192	//
	193	// Copy constructor
	194	//
	195	gen.Copy(*this);
	196	}
	197
e2afb3b6	198	//_______________________________________________________________________
aee8290b	199	AliGenerator & AliGenerator::operator=(const AliGenerator &gen)
	200	{
	201	//
	202	// Assignment operator
	203	//
	204	gen.Copy(*this);
	205	return (*this);
	206	}
	207
e2afb3b6	208	//_______________________________________________________________________
8918e700	209	void AliGenerator::Copy(AliGenerator &/* gen */) const
aee8290b	210	{
	211	//
	212	// Copy *this onto gen
	213	//
	214	Fatal("Copy","Not implemented!\n");
	215	}
	216
e2afb3b6	217	//_______________________________________________________________________
fe4da5cc	218	AliGenerator::~AliGenerator()
fe4da5cc	219	{
aee8290b	220	//
	221	// Destructor
	222	//
fe4da5cc	223	fOrigin.Set(0);
fe4da5cc	224	fOsigma.Set(0);
a08cd31a	225	if (fMCEvGen) {
	226	delete fMCEvGen;
	227	fMCEvGen=0;
475e6235	228	}
fe4da5cc	229	}
fe4da5cc	230
e2afb3b6	231	//_______________________________________________________________________
fe4da5cc	232	void AliGenerator::Init()
fe4da5cc	233	{
aee8290b	234	//
	235	// Dummy initialisation
	236	//
fe4da5cc	237	}
fe4da5cc	238
94de3818	239	//_______________________________________________________________________
	240	void AliGenerator::SetOrigin(Float_t ox, Float_t oy, Float_t oz)
	241	{
	242	//
	243	// Set the vertex for the generated tracks
	244	//
	245	fOrigin[0]=ox;
	246	fOrigin[1]=oy;
	247	fOrigin[2]=oz;
	248	}
	249
	250	//_______________________________________________________________________
	251	void AliGenerator::SetOrigin(const TLorentzVector &o)
	252	{
	253	//
	254	// Set the vertex for the generated tracks
	255	//
	256	fOrigin[0]=o[0];
	257	fOrigin[1]=o[1];
	258	fOrigin[2]=o[2];
	259	}
	260
	261	//_______________________________________________________________________
	262	void AliGenerator::SetSigma(Float_t sx, Float_t sy, Float_t sz)
	263	{
	264	//
	265	// Set the spread of the vertex
	266	//
	267	fOsigma[0]=sx;
	268	fOsigma[1]=sy;
	269	fOsigma[2]=sz;
	270	}
	271
	272	//_______________________________________________________________________
	273	void AliGenerator::SetMomentumRange(Float_t pmin, Float_t pmax)
	274	{
	275	//
	276	// Set the momentum range for the generated particles
	277	//
	278	fPMin = pmin;
	279	fPMax = pmax;
	280	SetBit(kMomentumRange);
	281	}
	282
	283	//_______________________________________________________________________
	284	void AliGenerator::SetPtRange(Float_t ptmin, Float_t ptmax)
	285	{
	286	//
	287	// Set the Pt range for the generated particles
	288	//
	289	fPtMin = ptmin;
	290	fPtMax = ptmax;
	291	SetBit(kPtRange);
	292	}
	293
	294	//_______________________________________________________________________
	295	void AliGenerator::SetPhiRange(Float_t phimin, Float_t phimax)
	296	{
	297	//
	298	// Set the Phi range for the generated particles
	299	//
	300	fPhiMin = TMath::Pi()*phimin/180;
c34578e7	301	fPhiMax = TMath::Pi()*phimax/180;
c34578e7	302	SetBit(kPhiRange);
94de3818	303	}
	304
	305	//_______________________________________________________________________
ca3a341c	306	void AliGenerator::SetYRange(Float_t ymin, Float_t ymax)
94de3818	307	{
	308	//
	309	// Set the Rapidity range for the generated particles
	310	//
	311	fYMin=ymin;
	312	fYMax=ymax;
	313	SetBit(kYRange);
	314	}
	315
	316	//_______________________________________________________________________
	317	void AliGenerator::SetVRange(Float_t vxmin, Float_t vxmax,
	318	Float_t vymin, Float_t vymax,
	319	Float_t vzmin, Float_t vzmax)
	320	{
	321	//
	322	// Set the vertex range for the generated particles
	323	//
	324	fVMin[0]=vxmin; fVMin[1]=vymin; fVMin[2]=vzmin;
	325	fVMax[0]=vxmax; fVMax[1]=vymax; fVMax[2]=vzmax;
	326	SetBit(kVertexRange);
	327	}
fe4da5cc	328
94de3818	329	//_______________________________________________________________________
	330	void AliGenerator::SetThetaRange(Float_t thetamin, Float_t thetamax)
	331	{
	332	//
	333	// Set the theta range for the generated particles
	334	//
	335	fThetaMin = TMath::Pi()*thetamin/180;
c34578e7	336	fThetaMax = TMath::Pi()*thetamax/180;
c34578e7	337	SetBit(kThetaRange);
94de3818	338	}
f89cabfe	339
	340	void AliGenerator::Vertex()
	341	{
	342	//
	343	// Obtain vertex for current event from external source or calculated (internal)
	344	//
	345	if (fVertexSource == kInternal) {
	346	VertexInternal();
0b910a04	347	} else if (fVertexSource == kContainer) {
	348	;
	349	} else if (fVertexSource == kExternal) {
f89cabfe	350	VertexExternal();
	351	}
	352	}
	353
e2afb3b6	354	//_______________________________________________________________________
f89cabfe	355	void AliGenerator::VertexExternal()
	356	{
	357	// Dummy !!!!!!
	358	// Obtain vertex from external source
	359	//
	360	// Should be something like fVertex = gAlice->GetVertex()
	361
	362	fVertex[0]=fVertex[1]=fVertex[2]=0;
	363	}
	364
e2afb3b6	365	//_______________________________________________________________________
f89cabfe	366	void AliGenerator::VertexInternal()
	367	{
	368	//
	369	// Obtain calculated vertex
	370	// Default is gaussian smearing
	371	Float_t random[6];
0b910a04	372	Float_t dv[3];
0b910a04	373	Int_t j;
0b910a04	374	dv[2] = 1.e10;
c1f70070	375	if (!TestBit(kVertexRange)) {
	376	while(TMath::Abs(dv[2]) > fCutVertexZ*fOsigma[2]) {
	377	Rndm(random,6);
	378	for (j=0; j < 3; j++) {
	379	dv[j] = fOsigma[j]TMath::Cos(2random[2j]TMath::Pi())*
	380	TMath::Sqrt(-2TMath::Log(random[2j+1]));
	381	}
0b910a04	382	}
c1f70070	383	for (j=0; j < 3; j++) fVertex[j] = fOrigin[j] + dv[j];
	384	} else {
	385	Rndm(random,3);
	386	for (j=0; j < 3; j++)
	387	fVertex[j] = fVMin[j] + random[j] * (fVMax[j] - fVMin[j]);
f89cabfe	388	}
	389	}
	390
e2afb3b6	391	//_______________________________________________________________________
642f15cf	392	void AliGenerator::PushTrack(Int_t done, Int_t parent, Int_t pdg,
69a313ec	393	Float_t pmom, Float_t vpos, Float_t *polar,
98490ea9	394	Float_t tof, TMCProcess mech, Int_t &ntr,
47c8bcbe	395	Float_t weight, Int_t is)
69a313ec	396	{
116cbefd	397	//
	398	// Loads one track on the stack
	399	//
69a313ec	400
69a313ec	401	if (fStack)
642f15cf	402	fStack->PushTrack(done, parent, pdg, pmom, vpos, polar, tof,
47c8bcbe	403	mech, ntr, weight, is);
69a313ec	404	else
642f15cf	405	gAlice->PushTrack(done, parent, pdg, pmom, vpos, polar, tof,
47c8bcbe	406	mech, ntr, weight, is);
69a313ec	407	}
e2afb3b6	408
e2afb3b6	409	//_______________________________________________________________________
642f15cf	410	void AliGenerator::PushTrack(Int_t done, Int_t parent, Int_t pdg,
69a313ec	411	Double_t px, Double_t py, Double_t pz, Double_t e,
	412	Double_t vx, Double_t vy, Double_t vz, Double_t tof,
	413	Double_t polx, Double_t poly, Double_t polz,
98490ea9	414	TMCProcess mech, Int_t &ntr, Float_t weight, Int_t is)
69a313ec	415	{
116cbefd	416	//
	417	// Loads one track on the stack
	418	//
69a313ec	419
69a313ec	420	if (fStack)
642f15cf	421	fStack->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
47c8bcbe	422	polx, poly, polz, mech, ntr, weight, is);
69a313ec	423	else
642f15cf	424	gAlice->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
47c8bcbe	425	polx, poly, polz, mech, ntr, weight, is);
69a313ec	426	}
f89cabfe	427
69a313ec	428
e2afb3b6	429	//_______________________________________________________________________
69a313ec	430	void AliGenerator:: KeepTrack(Int_t itrack)
69a313ec	431	{
116cbefd	432	//
	433	// Declare a track permanent on the stack
	434	//
69a313ec	435	if (fStack)
	436	fStack->KeepTrack(itrack);
	437	else
	438	gAlice->KeepTrack(itrack);
	439
	440	}
	441
e2afb3b6	442	//_______________________________________________________________________
69a313ec	443	void AliGenerator:: SetHighWaterMark(Int_t nt)
69a313ec	444	{
116cbefd	445	//
	446	// Internal function to set the maximum index used in the stack
	447	//
69a313ec	448	if (fStack)
	449	fStack->SetHighWaterMark(nt);
	450	else
	451	gAlice->SetHighWaterMark(nt);
	452
	453	}
0b910a04	454	void AliGenerator::FinishRun()
	455	{
	456	;
	457	}