[u/mrichter/AliRoot.git] / STEER / 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),
  fTimeOrigin(0.),
  fTime(0.),
  fEvPlane(0),
  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),
  fTimeOrigin(0.),
  fTime(0.),
  fEvPlane(0),
  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::GenerateN(Int_t ntimes)
{
// 
//  Run generator n times
//    Used by AliGenCocktail for adding extra signals in proportion to 
//    multiplicity/centrality
//  By default generates one AliGenHeader for each call to Generate()
//   Can be overloaded (e.g. AliGenBox and AliGenParam) to consolidate headers
//
  for (Int_t i=0; i < ntimes; i++) {
    Generate();
  }
}
//_______________________________________________________________________
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();
    fTime = 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];

	// In case of gaussian smearing we smear also the event/collision time
	Rndm(random,2);
	fTime = fTimeOrigin + fOsigma[2]/TMath::Ccgs()*
	  TMath::Cos(2*random[0]*TMath::Pi())*
	  TMath::Sqrt(-2*TMath::Log(random[1]));
	
    } else {
	Rndm(random,3);
	for (j=0; j < 3; j++)
	    fVertex[j] =  fVMin[j] + random[j] * (fVMax[j] - fVMin[j]);
	fTime = 0.;
    }
}

//_______________________________________________________________________
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
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>
af7ba10c	38	#include <TMCProcess.h>
fe4da5cc	39
594d8990	40	#include "AliLog.h"
116cbefd	41	#include "AliCollisionGeometry.h"
e2afb3b6	42	#include "AliConfig.h"
fe4da5cc	43	#include "AliGenerator.h"
fe4da5cc	44	#include "AliRun.h"
69a313ec	45	#include "AliStack.h"
5d12ce38	46	#include "AliMC.h"
14248849	47	#include "AliVertexGenerator.h"
69a313ec	48
fe4da5cc	49	ClassImp(AliGenerator)
fe4da5cc	50
fe4da5cc	51
e2afb3b6	52	//_______________________________________________________________________
e2afb3b6	53	AliGenerator::AliGenerator():
90e48c0c	54	TNamed(),
90e48c0c	55	AliRndm(),
f559aa82	56	fMCEvGen(0),
e2afb3b6	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),
0b910a04	74	fVertexSource(kInternal),
e2afb3b6	75	fCutVertexZ(0),
f0831961	76	fPileUpTimeWindow(-1.),
e2afb3b6	77	fTrackIt(0),
90e48c0c	78	fVertexGenerator(0),
e2afb3b6	79	fOrigin(3),
	80	fOsigma(3),
	81	fVertex(3),
21391258	82	fTimeOrigin(0.),
21391258	83	fTime(0.),
6078e216	84	fEvPlane(0),
2c5b3727	85	fStack(0),
d6eec420	86	fContainer(0),
e7c989e4	87	fCollisionGeometry(0),
	88	fEnergyCMS(0),
	89	fAProjectile(0),
	90	fZProjectile(0),
	91	fATarget(0),
	92	fZTarget(0),
	93	fProjectile(""),
	94	fTarget("")
fe4da5cc	95	{
aee8290b	96	//
	97	// Default constructor
	98	//
f98e49f0	99	if (gAlice) {
594d8990	100	AliDebug(1, "AliGenerator Default Constructor");
5d12ce38	101	AliMC * mc = gAlice->GetMCApp();
5d12ce38	102	if (mc) mc->SetGenerator(this);
f98e49f0	103	}
f98e49f0	104
de6d59e3	105	SetThetaRange(); ResetBit(kThetaRange);
	106	SetPhiRange(); ResetBit(kPhiRange);
	107	SetMomentumRange(); ResetBit(kMomentumRange);
	108	SetPtRange(); ResetBit(kPtRange);
	109	SetYRange(); ResetBit(kYRange);
fe4da5cc	110	SetNumberParticles();
4a3ba9d2	111	SetTrackingFlag();
f98e49f0	112	SetCutVertexZ();
f98e49f0	113
de6d59e3	114
fe4da5cc	115	fOrigin[0]=fOrigin[1]=fOrigin[2]=0;
fe4da5cc	116	fOsigma[0]=fOsigma[1]=fOsigma[2]=0;
f89cabfe	117	fVertex[0]=fVertex[1]=fVertex[2]=0;
f89cabfe	118
de6d59e3	119	fVMin[0]=fVMin[1]=fVMin[2]=0;
de6d59e3	120	fVMax[0]=fVMax[1]=fVMax[2]=10000;
fe4da5cc	121	}
fe4da5cc	122
e2afb3b6	123	//_______________________________________________________________________
e2afb3b6	124	AliGenerator::AliGenerator(Int_t npart):
90e48c0c	125	TNamed(),
90e48c0c	126	AliRndm(),
f559aa82	127	fMCEvGen(0),
e2afb3b6	128	fThetaMin(0),
	129	fThetaMax(0),
	130	fPhiMin(0),
	131	fPhiMax(0),
	132	fPMin(0),
	133	fPMax(0),
	134	fPtMin(0),
	135	fPtMax(0),
	136	fYMin(0),
	137	fYMax(0),
	138	fVMin(3),
	139	fVMax(3),
	140	fNpart(0),
	141	fParentWeight(0),
	142	fChildWeight(0),
	143	fAnalog(0),
	144	fVertexSmear(kNoSmear),
0b910a04	145	fVertexSource(kInternal),
e2afb3b6	146	fCutVertexZ(0),
f0831961	147	fPileUpTimeWindow(-1.),
e2afb3b6	148	fTrackIt(0),
90e48c0c	149	fVertexGenerator(0),
e2afb3b6	150	fOrigin(3),
	151	fOsigma(3),
	152	fVertex(3),
21391258	153	fTimeOrigin(0.),
21391258	154	fTime(0.),
6078e216	155	fEvPlane(0),
2c5b3727	156	fStack(0),
d6eec420	157	fContainer(0),
e7c989e4	158	fCollisionGeometry(0),
	159	fEnergyCMS(0),
	160	fAProjectile(0),
	161	fZProjectile(0),
	162	fATarget(0),
	163	fZTarget(0),
	164	fProjectile(""),
	165	fTarget("")
fe4da5cc	166	{
aee8290b	167	//
	168	// Standard constructor
	169	//
f98e49f0	170	if (gAlice) {
594d8990	171	AliDebug(1, "AliGenerator Constructor initializing number of particles");
5d12ce38	172	AliMC * mc = gAlice->GetMCApp();
5d12ce38	173	if (mc) mc->SetGenerator(this);
f98e49f0	174	}
f98e49f0	175
de6d59e3	176	SetThetaRange(); ResetBit(kThetaRange);
	177	SetPhiRange(); ResetBit(kPhiRange);
	178	SetMomentumRange(); ResetBit(kMomentumRange);
	179	SetPtRange(); ResetBit(kPtRange);
	180	SetYRange(); ResetBit(kYRange);
4a3ba9d2	181	SetTrackingFlag();
f98e49f0	182	SetCutVertexZ();
de6d59e3	183
fe4da5cc	184	fOrigin[0]=fOrigin[1]=fOrigin[2]=0;
fe4da5cc	185	fOsigma[0]=fOsigma[1]=fOsigma[2]=0;
f89cabfe	186	fVertex[0]=fVertex[1]=fVertex[2]=0;
f89cabfe	187
fe4da5cc	188	fVMin[0]=fVMin[1]=fVMin[2]=0;
fe4da5cc	189	fVMax[0]=fVMax[1]=fVMax[2]=10000;
de6d59e3	190
de6d59e3	191	SetNumberParticles(npart);
9e1a0ddb	192
69a313ec	193	AliConfig::Instance()->Add(this);
fe4da5cc	194	}
fe4da5cc	195
e2afb3b6	196	//_______________________________________________________________________
fe4da5cc	197	AliGenerator::~AliGenerator()
fe4da5cc	198	{
aee8290b	199	//
	200	// Destructor
	201	//
fe4da5cc	202	fOrigin.Set(0);
fe4da5cc	203	fOsigma.Set(0);
a08cd31a	204	if (fMCEvGen) {
	205	delete fMCEvGen;
	206	fMCEvGen=0;
475e6235	207	}
fe4da5cc	208	}
fe4da5cc	209
e2afb3b6	210	//_______________________________________________________________________
fe4da5cc	211	void AliGenerator::Init()
fe4da5cc	212	{
aee8290b	213	//
	214	// Dummy initialisation
	215	//
fe4da5cc	216	}
fe4da5cc	217
94de3818	218	//_______________________________________________________________________
d5615b85	219	void AliGenerator::GenerateN(Int_t ntimes)
	220	{
	221	//
	222	// Run generator n times
	223	// Used by AliGenCocktail for adding extra signals in proportion to
	224	// multiplicity/centrality
	225	// By default generates one AliGenHeader for each call to Generate()
	226	// Can be overloaded (e.g. AliGenBox and AliGenParam) to consolidate headers
	227	//
	228	for (Int_t i=0; i < ntimes; i++) {
	229	Generate();
	230	}
	231	}
	232	//_______________________________________________________________________
94de3818	233	void AliGenerator::SetOrigin(Float_t ox, Float_t oy, Float_t oz)
	234	{
	235	//
	236	// Set the vertex for the generated tracks
	237	//
	238	fOrigin[0]=ox;
	239	fOrigin[1]=oy;
	240	fOrigin[2]=oz;
	241	}
	242
	243	//_______________________________________________________________________
	244	void AliGenerator::SetOrigin(const TLorentzVector &o)
	245	{
	246	//
	247	// Set the vertex for the generated tracks
	248	//
	249	fOrigin[0]=o[0];
	250	fOrigin[1]=o[1];
	251	fOrigin[2]=o[2];
	252	}
	253
	254	//_______________________________________________________________________
	255	void AliGenerator::SetSigma(Float_t sx, Float_t sy, Float_t sz)
	256	{
	257	//
	258	// Set the spread of the vertex
	259	//
	260	fOsigma[0]=sx;
	261	fOsigma[1]=sy;
	262	fOsigma[2]=sz;
	263	}
	264
	265	//_______________________________________________________________________
	266	void AliGenerator::SetMomentumRange(Float_t pmin, Float_t pmax)
	267	{
	268	//
	269	// Set the momentum range for the generated particles
	270	//
	271	fPMin = pmin;
	272	fPMax = pmax;
	273	SetBit(kMomentumRange);
	274	}
	275
	276	//_______________________________________________________________________
	277	void AliGenerator::SetPtRange(Float_t ptmin, Float_t ptmax)
	278	{
	279	//
	280	// Set the Pt range for the generated particles
	281	//
	282	fPtMin = ptmin;
	283	fPtMax = ptmax;
	284	SetBit(kPtRange);
	285	}
	286
	287	//_______________________________________________________________________
	288	void AliGenerator::SetPhiRange(Float_t phimin, Float_t phimax)
	289	{
	290	//
	291	// Set the Phi range for the generated particles
	292	//
	293	fPhiMin = TMath::Pi()*phimin/180;
c34578e7	294	fPhiMax = TMath::Pi()*phimax/180;
c34578e7	295	SetBit(kPhiRange);
94de3818	296	}
	297
	298	//_______________________________________________________________________
ca3a341c	299	void AliGenerator::SetYRange(Float_t ymin, Float_t ymax)
94de3818	300	{
	301	//
	302	// Set the Rapidity range for the generated particles
	303	//
	304	fYMin=ymin;
	305	fYMax=ymax;
	306	SetBit(kYRange);
	307	}
	308
	309	//_______________________________________________________________________
	310	void AliGenerator::SetVRange(Float_t vxmin, Float_t vxmax,
	311	Float_t vymin, Float_t vymax,
	312	Float_t vzmin, Float_t vzmax)
	313	{
	314	//
	315	// Set the vertex range for the generated particles
	316	//
	317	fVMin[0]=vxmin; fVMin[1]=vymin; fVMin[2]=vzmin;
	318	fVMax[0]=vxmax; fVMax[1]=vymax; fVMax[2]=vzmax;
	319	SetBit(kVertexRange);
	320	}
fe4da5cc	321
94de3818	322	//_______________________________________________________________________
	323	void AliGenerator::SetThetaRange(Float_t thetamin, Float_t thetamax)
	324	{
	325	//
	326	// Set the theta range for the generated particles
	327	//
	328	fThetaMin = TMath::Pi()*thetamin/180;
c34578e7	329	fThetaMax = TMath::Pi()*thetamax/180;
c34578e7	330	SetBit(kThetaRange);
94de3818	331	}
f89cabfe	332
	333	void AliGenerator::Vertex()
	334	{
	335	//
	336	// Obtain vertex for current event from external source or calculated (internal)
	337	//
	338	if (fVertexSource == kInternal) {
	339	VertexInternal();
0b910a04	340	} else if (fVertexSource == kContainer) {
	341	;
	342	} else if (fVertexSource == kExternal) {
f89cabfe	343	VertexExternal();
	344	}
	345	}
	346
e2afb3b6	347	//_______________________________________________________________________
f89cabfe	348	void AliGenerator::VertexExternal()
f89cabfe	349	{
f89cabfe	350	//
14248849	351	// Obtain vertex from external source (vertex generator)
	352	//
	353	TVector3 vertex = fVertexGenerator->GetVertex();
	354	fVertex[0] = vertex.X();
	355	fVertex[1] = vertex.Y();
	356	fVertex[2] = vertex.Z();
21391258	357	fTime = 0.;
f89cabfe	358	}
f89cabfe	359
e2afb3b6	360	//_______________________________________________________________________
f89cabfe	361	void AliGenerator::VertexInternal()
	362	{
	363	//
	364	// Obtain calculated vertex
	365	// Default is gaussian smearing
	366	Float_t random[6];
0b910a04	367	Float_t dv[3];
0b910a04	368	Int_t j;
0b910a04	369	dv[2] = 1.e10;
c1f70070	370	if (!TestBit(kVertexRange)) {
	371	while(TMath::Abs(dv[2]) > fCutVertexZ*fOsigma[2]) {
	372	Rndm(random,6);
	373	for (j=0; j < 3; j++) {
	374	dv[j] = fOsigma[j]TMath::Cos(2random[2j]TMath::Pi())*
	375	TMath::Sqrt(-2TMath::Log(random[2j+1]));
	376	}
0b910a04	377	}
c1f70070	378	for (j=0; j < 3; j++) fVertex[j] = fOrigin[j] + dv[j];
21391258	379
	380	// In case of gaussian smearing we smear also the event/collision time
	381	Rndm(random,2);
	382	fTime = fTimeOrigin + fOsigma[2]/TMath::Ccgs()*
	383	TMath::Cos(2random[0]TMath::Pi())*
	384	TMath::Sqrt(-2*TMath::Log(random[1]));
	385
c1f70070	386	} else {
	387	Rndm(random,3);
	388	for (j=0; j < 3; j++)
	389	fVertex[j] = fVMin[j] + random[j] * (fVMax[j] - fVMin[j]);
21391258	390	fTime = 0.;
f89cabfe	391	}
	392	}
	393
e2afb3b6	394	//_______________________________________________________________________
642f15cf	395	void AliGenerator::PushTrack(Int_t done, Int_t parent, Int_t pdg,
69a313ec	396	Float_t pmom, Float_t vpos, Float_t *polar,
98490ea9	397	Float_t tof, TMCProcess mech, Int_t &ntr,
47c8bcbe	398	Float_t weight, Int_t is)
69a313ec	399	{
116cbefd	400	//
	401	// Loads one track on the stack
	402	//
f0831961	403
69a313ec	404	if (fStack)
642f15cf	405	fStack->PushTrack(done, parent, pdg, pmom, vpos, polar, tof,
47c8bcbe	406	mech, ntr, weight, is);
69a313ec	407	else
5d12ce38	408	gAlice->GetMCApp()->PushTrack(done, parent, pdg, pmom, vpos, polar, tof,
47c8bcbe	409	mech, ntr, weight, is);
69a313ec	410	}
e2afb3b6	411
e2afb3b6	412	//_______________________________________________________________________
642f15cf	413	void AliGenerator::PushTrack(Int_t done, Int_t parent, Int_t pdg,
69a313ec	414	Double_t px, Double_t py, Double_t pz, Double_t e,
	415	Double_t vx, Double_t vy, Double_t vz, Double_t tof,
	416	Double_t polx, Double_t poly, Double_t polz,
98490ea9	417	TMCProcess mech, Int_t &ntr, Float_t weight, Int_t is)
69a313ec	418	{
116cbefd	419	//
	420	// Loads one track on the stack
	421	//
69a313ec	422
69a313ec	423	if (fStack)
642f15cf	424	fStack->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
47c8bcbe	425	polx, poly, polz, mech, ntr, weight, is);
69a313ec	426	else
5d12ce38	427	gAlice->GetMCApp()->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
47c8bcbe	428	polx, poly, polz, mech, ntr, weight, is);
69a313ec	429	}
f89cabfe	430
69a313ec	431
e2afb3b6	432	//_______________________________________________________________________
69a313ec	433	void AliGenerator:: KeepTrack(Int_t itrack)
69a313ec	434	{
116cbefd	435	//
	436	// Declare a track permanent on the stack
	437	//
69a313ec	438	if (fStack)
	439	fStack->KeepTrack(itrack);
	440	else
5d12ce38	441	gAlice->GetMCApp()->KeepTrack(itrack);
69a313ec	442
	443	}
	444
e2afb3b6	445	//_______________________________________________________________________
69a313ec	446	void AliGenerator:: SetHighWaterMark(Int_t nt)
69a313ec	447	{
116cbefd	448	//
	449	// Internal function to set the maximum index used in the stack
	450	//
69a313ec	451	if (fStack)
	452	fStack->SetHighWaterMark(nt);
	453	else
5d12ce38	454	gAlice->GetMCApp()->SetHighWaterMark(nt);
69a313ec	455
69a313ec	456	}
0b910a04	457	void AliGenerator::FinishRun()
	458	{
	459	;
	460	}