/*
$Log$
+Revision 1.28 2001/03/09 13:01:41 morsch
+- enum constants for paramterisation type (particle family) moved to AliGen*lib.h
+- use AliGenGSIlib::kUpsilon, AliGenPHOSlib::kEtaPrime to access the constants
+
+Revision 1.27 2001/02/02 15:21:10 morsch
+Set high water mark after last particle.
+Use Vertex() method for Vertex.
+
+Revision 1.26 2000/12/21 16:24:06 morsch
+Coding convention clean-up
+
+Revision 1.25 2000/11/30 07:12:50 alibrary
+Introducing new Rndm and QA classes
+
+Revision 1.24 2000/10/18 19:11:27 hristov
+Division by zero fixed
+
+Revision 1.23 2000/10/02 21:28:06 fca
+Removal of useless dependecies via forward declarations
+
+Revision 1.22 2000/09/12 14:14:55 morsch
+Call fDecayer->ForceDecay() at the beginning of Generate().
+
+Revision 1.21 2000/09/08 15:39:01 morsch
+Handle the case fForceDecay=all during the generation, i.e. select all secondaries.
+
+Revision 1.20 2000/09/06 14:35:44 morsch
+Use AliDecayerPythia for particle decays.
+
+Revision 1.19 2000/07/11 18:24:56 fca
+Coding convention corrections + few minor bug fixes
+
Revision 1.18 2000/06/29 21:08:27 morsch
All paramatrisation libraries derive from the pure virtual base class AliGenLib.
This allows to pass a pointer to a library directly to AliGenParam and avoids the
*/
#include "AliGenParam.h"
+#include "AliDecayerPythia.h"
#include "AliGenMUONlib.h"
#include "AliRun.h"
-#include "AliPythia.h"
#include <TParticle.h>
+#include <TParticlePDG.h>
+#include <TDatabasePDG.h>
+#include <TLorentzVector.h>
+
#include <TF1.h>
ClassImp(AliGenParam)
//____________________________________________________________
//____________________________________________________________
AliGenParam::AliGenParam()
- :AliGenerator()
{
// Deafault constructor
fPtPara = 0;
fYPara = 0;
- fParam = jpsi_p;
- fAnalog = analog;
+ fParam = 0;
+ fAnalog = kAnalog;
SetCutOnChild();
SetChildMomentumRange();
SetChildPtRange();
SetChildPhiRange();
SetChildThetaRange();
SetDeltaPt();
+//
+// Set random number generator
+ sRandom = fRandom;
}
-AliGenParam::AliGenParam(Int_t npart, AliGenLib * Library, Param_t param, char* tname):AliGenerator(npart)
+AliGenParam::AliGenParam(Int_t npart, AliGenLib * Library, Int_t param, char* tname):AliGenerator(npart)
{
// Constructor using number of particles parameterisation id and library
fPtPara = 0;
fYPara = 0;
fParam = param;
- fAnalog = analog;
+ fAnalog = kAnalog;
fChildSelect.Set(5);
for (Int_t i=0; i<5; i++) fChildSelect[i]=0;
SetForceDecay();
SetChildPhiRange();
SetChildThetaRange();
SetDeltaPt();
+//
+// Set random number generator
+ sRandom = fRandom;
}
//____________________________________________________________
-AliGenParam::AliGenParam(Int_t npart, Param_t param, char* tname):AliGenerator(npart)
+AliGenParam::AliGenParam(Int_t npart, Int_t param, char* tname):AliGenerator(npart)
{
// Constructor using parameterisation id and number of particles
//
- AliGenLib* Library = new AliGenMUONlib();
+ AliGenLib* pLibrary = new AliGenMUONlib();
- fPtParaFunc = Library->GetPt(param, tname);
- fYParaFunc = Library->GetY (param, tname);
- fIpParaFunc = Library->GetIp(param, tname);
+ fPtParaFunc = pLibrary->GetPt(param, tname);
+ fYParaFunc = pLibrary->GetY (param, tname);
+ fIpParaFunc = pLibrary->GetIp(param, tname);
fPtPara = 0;
fYPara = 0;
fParam = param;
- fAnalog = analog;
+ fAnalog = kAnalog;
fChildSelect.Set(5);
for (Int_t i=0; i<5; i++) fChildSelect[i]=0;
SetForceDecay();
SetDeltaPt();
}
-AliGenParam::AliGenParam(Int_t npart, Param_t param,
+AliGenParam::AliGenParam(Int_t npart, Int_t param,
Double_t (*PtPara) (Double_t*, Double_t*),
Double_t (*YPara ) (Double_t* ,Double_t*),
- Int_t (*IpPara) ())
+ Int_t (*IpPara) (TRandom *))
:AliGenerator(npart)
{
// Constructor
fPtPara = 0;
fYPara = 0;
fParam = param;
- fAnalog = analog;
+ fAnalog = kAnalog;
fChildSelect.Set(5);
for (Int_t i=0; i<5; i++) fChildSelect[i]=0;
SetForceDecay();
void AliGenParam::Init()
{
// Initialisation
- SetMC(new AliPythia());
- fPythia= (AliPythia*) fgMCEvGen;
-
+
+ fDecayer = new AliDecayerPythia();
//Begin_Html
/*
<img src="picts/AliGenParam.gif">
Float_t intPt0 = ptPara->Integral(0,15);
Float_t intPtS = ptPara->Integral(fPtMin,fPtMax);
Float_t phiWgt=(fPhiMax-fPhiMin)/2./TMath::Pi();
- if (fAnalog == analog) {
+ if (fAnalog == kAnalog) {
fYWgt = intYS/fdNdy0;
fPtWgt = intPtS/intPt0;
fParentWeight = fYWgt*fPtWgt*phiWgt/fNpart;
}
//
// particle decay related initialization
- fPythia->DefineParticles();
-// semimuonic decays of charm and beauty
- fPythia->ForceDecay(fForceDecay);
+ fDecayer->SetForceDecay(fForceDecay);
+ fDecayer->Init();
+
//
switch (fForceDecay)
{
- case semielectronic:
- case dielectron:
- case b_jpsi_dielectron:
- case b_psip_dielectron:
+ case kSemiElectronic:
+ case kDiElectron:
+ case kBJpsiDiElectron:
+ case kBPsiPrimeDiElectron:
fChildSelect[0]=11;
break;
- case semimuonic:
- case dimuon:
- case b_jpsi_dimuon:
- case b_psip_dimuon:
+ case kSemiMuonic:
+ case kDiMuon:
+ case kBJpsiDiMuon:
+ case kBPsiPrimeDiMuon:
fChildSelect[0]=13;
break;
- case pitomu:
+ case kPiToMu:
fChildSelect[0]=13;
break;
- case katomu:
+ case kKaToMu:
fChildSelect[0]=13;
break;
- case nodecay:
+ case kHadronicD:
+// Implement me !!
+ break;
+ case kNoDecay:
break;
- case all:
+ case kAll:
break;
}
}
// However, light mesons are directly tracked by GEANT
// setting fForceDecay = nodecay (SetForceDecay(nodecay))
//
-
-
+//
+// Reinitialize decayer
+ fDecayer->Init();
+//
Float_t polar[3]= {0,0,0}; // Polarisation of the parent particle (for GEANT tracking)
Float_t origin0[3]; // Origin of the generated parent particle (for GEANT tracking)
Float_t pt, pl, ptot; // Transverse, logitudinal and total momenta of the parent particle
static TClonesArray *particles;
//
if(!particles) particles=new TClonesArray("TParticle",1000);
+
+ static TDatabasePDG *pDataBase = new TDatabasePDG();
+ if(!pDataBase) pDataBase = new TDatabasePDG();
//
Float_t random[6];
// Calculating vertex position per event
for (j=0;j<3;j++) origin0[j]=fOrigin[j];
if(fVertexSmear==kPerEvent) {
- gMC->Rndm(random,6);
- for (j=0;j<3;j++) {
- origin0[j]+=fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
- TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
- }
+// Rndm(random,6);
+// for (j=0;j<3;j++) {
+// origin0[j]+=fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
+// TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
+// TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
+// }
+// }
+ Vertex();
+ for (j=0;j<3;j++) origin0[j]=fVertex[j];
}
+
Int_t ipa=0;
// Generating fNpart particles
while (ipa<fNpart) {
while(1) {
//
// particle type
- Int_t iPart = fIpParaFunc();
- fChildWeight=(fPythia->GetBraPart(iPart))*fParentWeight;
- Float_t am=fPythia->GetPMAS(fPythia->Lucomp(iPart),1);
- gMC->Rndm(random,2);
+ Int_t iPart = fIpParaFunc(fRandom);
+ fChildWeight=(fDecayer->GetPartialBranchingRatio(iPart))*fParentWeight;
+ TParticlePDG *particle = pDataBase->GetParticle(iPart);
+ Float_t am = particle->Mass();
+
+ Rndm(random,2);
//
// phi
phi=fPhiMin+random[0]*(fPhiMax-fPhiMin);
ty=Float_t(TMath::TanH(fYPara->GetRandom()));
//
// pT
- if (fAnalog == analog) {
+ if (fAnalog == kAnalog) {
pt=fPtPara->GetRandom();
wgtp=fParentWeight;
wgtch=fChildWeight;
wgtch=fChildWeight*fPtParaFunc(& ptd, &dummy);
}
xmt=sqrt(pt*pt+am*am);
+ if (TMath::Abs(ty)==1) ty=0;
pl=xmt*ty/sqrt(1.-ty*ty);
theta=TMath::ATan2(pt,pl);
// Cut on theta
p[1]=pt*TMath::Sin(phi);
p[2]=pl;
if(fVertexSmear==kPerTrack) {
- gMC->Rndm(random,6);
+ Rndm(random,6);
for (j=0;j<3;j++) {
origin0[j]=
fOrigin[j]+fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
// if fForceDecay == none Primary particle is tracked by GEANT
// (In the latest, make sure that GEANT actually does all the decays you want)
//
- if (fForceDecay != nodecay) {
+ if (fForceDecay != kNoDecay) {
// Using lujet to decay particle
Float_t energy=TMath::Sqrt(ptot*ptot+am*am);
- fPythia->DecayParticle(iPart,energy,theta,phi);
+ TLorentzVector pmom(p[0], p[1], p[2], energy);
+ fDecayer->Decay(iPart,&pmom);
//
// select decay particles
- Int_t np=fPythia->ImportParticles(particles,"All");
+ Int_t np=fDecayer->ImportParticles(particles);
Int_t ncsel=0;
for (i = 1; i<np; i++) {
TParticle * iparticle = (TParticle *) particles->At(i);
Int_t kf = iparticle->GetPdgCode();
//
// children
- if (ChildSelected(TMath::Abs(kf)))
+ if (ChildSelected(TMath::Abs(kf)) || fForceDecay == kAll)
{
pc[0]=iparticle->Px();
pc[1]=iparticle->Py();
//
// parent
gAlice->
- SetTrack(0,-1,iPart,p,origin0,polar,0,"Primary",nt,wgtp);
+ SetTrack(0,-1,iPart,p,origin0,polar,0,kPPrimary,nt,wgtp);
iparent=nt;
gAlice->KeepTrack(nt);
for (i=0; i< ncsel; i++) {
gAlice->SetTrack(fTrackIt,iparent,kfch[i],
&pch[i][0],och,polar,
- 0,"Decay",nt,wgtch);
+ 0,kPDecay,nt,wgtch);
gAlice->KeepTrack(nt);
}
} // Decays by Lujet
else // nodecay option, so parent will be tracked by GEANT (pions, kaons, eta, omegas, baryons)
{
gAlice->
- SetTrack(fTrackIt,-1,iPart,p,origin0,polar,0,"Primary",nt,wgtp);
+ SetTrack(fTrackIt,-1,iPart,p,origin0,polar,0,kPPrimary,nt,wgtp);
ipa++;
}
break;
} // while
} // event loop
+ gAlice->SetHighWaterMark(nt);
+
}
Bool_t AliGenParam::ChildSelected(Int_t ip)
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff