#ifndef ALIGENERATOR_H
#define ALIGENERATOR_H
#include <TArrayF.h>
#include <TLorentzVector.h>
#include <TMCProcess.h>
#include "AliRndm.h"
class AliVertexGenerator;
class AliCollisionGeometry;
class AliGenEventHeader;
class AliStack;
class TGenerator;
typedef enum { kNoSmear, kPerEvent, kPerTrack } VertexSmear_t;
typedef enum { kExternal, kInternal, kContainer} VertexSource_t;
class AliGenerator : public TNamed, public AliRndm
{
public:
AliGenerator();
AliGenerator(Int_t npart);
virtual ~AliGenerator();
virtual void Init();
virtual void SetOrigin(Float_t ox, Float_t oy, Float_t oz);
virtual void SetOrigin(const TLorentzVector &o);
virtual void SetSigma(Float_t sx, Float_t sy, Float_t sz);
virtual void SetSigmaZ(Float_t sz) {fOsigma[2] = sz;}
virtual void SetMomentumRange(Float_t pmin=0, Float_t pmax=1.e10);
virtual void SetPtRange(Float_t ptmin=0, Float_t ptmax=1.e10);
virtual void SetPhiRange(Float_t phimin = 0., Float_t phimax = 360.);
virtual void SetYRange(Float_t ymin=-100, Float_t ymax=100);
virtual void SetVRange(Float_t vxmin, Float_t vxmax,
Float_t vymin, Float_t vymax,
Float_t vzmin, Float_t vzmax);
virtual void SetNumberParticles(Int_t npart=100) {fNpart=npart;}
virtual Int_t NumberParticles() const {return fNpart;}
virtual void SetThetaRange(Float_t thetamin=0, Float_t thetamax=180);
virtual void GenerateN(Int_t ntimes);
virtual void Generate()=0;
virtual void SetParentWeight(Float_t wgt) {fParentWeight=wgt;}
virtual void SetChildWeight(Float_t wgt) {fChildWeight=wgt;}
virtual void SetAnalog(Int_t flag=1) {fAnalog=flag;}
virtual void SetVertexSmear(VertexSmear_t smear) {fVertexSmear = smear;}
virtual void SetCutVertexZ(Float_t cut=999999.) {fCutVertexZ = cut;}
virtual void SetVertexSource(VertexSource_t source = kInternal) {fVertexSource = source;}
virtual void SetVertex(Float_t vx, Float_t vy, Float_t vz, Float_t t = 0)
{fVertex[0] = vx; fVertex[1] = vy; fVertex[2] = vz; fTime = t;}
void SetVertexGenerator(AliVertexGenerator* vertexGenerator)
{fVertexGenerator = vertexGenerator; fVertexSource = kExternal; fVertexSmear = kPerEvent;}
void SetPileUpTimeWindow(Float_t pileUpTimeW) {fPileUpTimeWindow = pileUpTimeW;}
virtual void SetTime(Float_t time)
{fTime = time;}
virtual void SetTimeOrigin(Float_t timeorig)
{fTimeOrigin = timeorig;}
virtual void SetTrackingFlag(Int_t flag=1) {fTrackIt=flag;}
void Vertex();
void VertexExternal();
virtual void VertexInternal();
virtual void FinishRun();
virtual void SetMC(TGenerator *theMC) {fMCEvGen =theMC;}
virtual TGenerator* GetMC() const {return fMCEvGen;}
virtual void AddHeader(AliGenEventHeader* ) {;}
virtual void SetContainer(AliGenerator* container) {fContainer = container;}
virtual void SetEventPlane(Float_t evPlane) {fEvPlane = evPlane; }
virtual void GetOrigin(Float_t &ox, Float_t &oy, Float_t &oz) const
{ox=fOrigin.At(0);oy=fOrigin.At(1);oz=fOrigin.At(2);}
virtual void GetOrigin(TLorentzVector &o) const
{o[0]=fOrigin.At(0);o[1]=fOrigin.At(1);o[2]=fOrigin.At(2);o[3]=0;}
void SetStack (AliStack *stack) {fStack = stack;}
AliStack* GetStack(){return fStack;}
virtual Bool_t ProvidesCollisionGeometry() const {return kFALSE;}
virtual Bool_t NeedsCollisionGeometry() const {return kFALSE;}
virtual AliCollisionGeometry* CollisionGeometry() const {return fCollisionGeometry;}
virtual void SetCollisionGeometry(AliCollisionGeometry* geom) {fCollisionGeometry = geom;}
virtual Float_t GetEnergyCMS() const { return fEnergyCMS; }
virtual void SetEnergyCMS(Float_t energy = 0) { fEnergyCMS = energy; }
virtual void GetProjectile(TString& tar, Int_t& a, Int_t& z) const
{tar = fProjectile; a = fAProjectile; z = fZProjectile;}
virtual void GetTarget(TString& tar, Int_t& a, Int_t& z) const
{tar = fTarget; a = fATarget; z = fZTarget;}
virtual void SetProjectile(TString proj="", Int_t a = 0, Int_t z = 0)
{fProjectile = proj; fAProjectile = a; fZProjectile = z;}
virtual void SetTarget(TString tar="", Int_t a = 0, Int_t z = 0)
{fTarget = tar; fATarget = a; fZTarget = z;}
virtual void SetSeed(UInt_t seed);
protected:
virtual void 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 = 1, Int_t is = 0);
virtual void 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 = 1, Int_t is = 0);
virtual void KeepTrack(Int_t itrack);
virtual void SetHighWaterMark(Int_t nt);
protected:
TGenerator* fMCEvGen;
Float_t fThetaMin;
Float_t fThetaMax;
Float_t fPhiMin;
Float_t fPhiMax;
Float_t fPMin;
Float_t fPMax;
Float_t fPtMin;
Float_t fPtMax;
Float_t fYMin;
Float_t fYMax;
TArrayF fVMin;
TArrayF fVMax;
Int_t fNpart;
Float_t fParentWeight;
Float_t fChildWeight;
Int_t fAnalog;
VertexSmear_t fVertexSmear;
VertexSource_t fVertexSource;
Float_t fCutVertexZ;
Float_t fPileUpTimeWindow;
Int_t fTrackIt;
AliVertexGenerator* fVertexGenerator;
TArrayF fOrigin;
TArrayF fOsigma;
TArrayF fVertex;
Float_t fTimeOrigin;
Float_t fTime;
Float_t fEvPlane;
AliStack* fStack;
AliGenerator* fContainer;
AliCollisionGeometry* fCollisionGeometry;
enum {kThetaRange = BIT(14),
kVertexRange = BIT(15),
kPhiRange = BIT(16),
kPtRange = BIT(17),
kYRange = BIT(18),
kMomentumRange = BIT(19),
kEtaRange = BIT(20)
};
Float_t fEnergyCMS;
Int_t fAProjectile;
Int_t fZProjectile;
Int_t fATarget;
Int_t fZTarget;
TString fProjectile;
TString fTarget;
private:
AliGenerator(const AliGenerator &gen);
AliGenerator & operator=(const AliGenerator &gen);
ClassDef(AliGenerator,5)
};
#endif