#include <TF1.h>
#include <TParticle.h>
#include <TPDGCode.h>
+#include <TVirtualMC.h>
#include "AliConst.h"
#include "AliDecayer.h"
ClassImp(AliGenHIJINGpara)
-AliGenHIJINGpara::AliGenHIJINGpara(const AliGenHIJINGpara & para)
+
+AliGenHIJINGpara::AliGenHIJINGpara(const AliGenHIJINGpara & para):
+ AliGenerator(para)
{
-// copy constructor
+// Copy constructor
+ para.Copy(*this);
}
//_____________________________________________________________________________
fETApic = new TF1("etapic",&etapic,etaMin,etaMax,0);
fETAkac = new TF1("etakac",&etakac,etaMin,etaMax,0);
- TF1 etaPic0("etapic",&etapic,-7,7,0);
- TF1 etaKac0("etakac",&etakac,-7,7,0);
+ TF1 etaPic0("etaPic0",&etapic,-7,7,0);
+ TF1 etaKac0("etaKac0",&etakac,-7,7,0);
- TF1 ptPic0("ptpi",&ptpi,0.,15.,0);
- TF1 ptKac0("ptka",&ptka,0.,15.,0);
+ TF1 ptPic0("ptPic0",&ptpi,0.,15.,0);
+ TF1 ptKac0("ptKac0",&ptka,0.,15.,0);
Float_t intETApi = etaPic0.Integral(-0.5, 0.5);
Float_t intETAka = etaKac0.Integral(-0.5, 0.5);
// Fraction of events corresponding to the selected phi-range
Float_t phiFrac = (fPhiMax-fPhiMin)/2/TMath::Pi();
+
fParentWeight = Float_t(fNpart)/(intETASel*ptFrac*phiFrac);
+ if (fAnalog != 0) {
+ fPtWgtPi = (fPtMax - fPtMin) / fPtpi->Integral(0., 20.);
+ fPtWgtKa = (fPtMax - fPtMin) / fPtka->Integral(0., 20.);
+ fParentWeight = Float_t(fNpart)/(intETASel*phiFrac);
+ }
+
+
printf("%s: The number of particles in the selected kinematic region corresponds to %f percent of a full event\n ",
ClassName(),100.*fParentWeight);
const Int_t kKaons[4] = {kK0Long, kK0Short, kKPlus, kKMinus};
//
Float_t origin[3];
- Float_t pt, pl, ptot;
+ Float_t pt, pl, ptot, wgt;
Float_t phi, theta;
Float_t p[3];
Int_t i, part, j;
eventVertex[0] = origin[0];
eventVertex[1] = origin[1];
eventVertex[2] = origin[2];
-
+
for(i=0;i<fNpart;i++) {
while(1) {
- Rndm(random,3);
+ Rndm(random,4);
if(random[0]<kBorne) {
part=kPions[Int_t (random[1]*3)];
ptf=fPtpi;
etaf=fETApic;
+ wgt = fPtWgtPi;
} else {
part=kKaons[Int_t (random[1]*4)];
ptf=fPtka;
etaf=fETAkac;
+ wgt = fPtWgtKa;
}
phi=fPhiMin+random[2]*(fPhiMax-fPhiMin);
theta=2*TMath::ATan(TMath::Exp(-etaf->GetRandom()));
if(theta<fThetaMin || theta>fThetaMax) continue;
- pt=ptf->GetRandom();
+
+ if (fAnalog == 0) {
+ pt = ptf->GetRandom();
+ } else {
+ pt = fPtMin + random[3] * (fPtMax - fPtMin);
+ }
+
+
pl=pt/TMath::Tan(theta);
ptot=TMath::Sqrt(pt*pt+pl*pl);
if(ptot<fPMin || ptot>fPMax) continue;
TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
}
}
+
+ if (fAnalog == 0) {
+ wgt = fParentWeight;
+ } else {
+ wgt *= (fParentWeight * ptf->Eval(pt));
+ }
+
+
if (part == kPi0 && fPi0Decays){
//
// Decay pi0 if requested
gAlice->SetGenEventHeader(header);
}
-AliGenHIJINGpara& AliGenHIJINGpara::operator=(const AliGenHIJINGpara& rhs)
-{
-// Assignment operator
- return *this;
-}
-
void AliGenHIJINGpara::SetPtRange(Float_t ptmin, Float_t ptmax) {
AliGenerator::SetPtRange(ptmin, ptmax);
}
}
fNt = nt;
}
+
+void AliGenHIJINGpara::Copy(AliGenHIJINGpara &) const
+{
+ Fatal("Copy","Not implemented!\n");
+}