Float_t polar[3] = {0,0,0};
Float_t origin0[3] = {0,0,0};
Float_t origin[3] = {0,0,0};
+ Float_t time0 = 0.;
+ Float_t time = 0.;
fNprimaries = 0;
Int_t nt = 0; //output parameter for PushTrack
Vertex();
for (int j=0; j < 3; j++) origin0[j] = fVertex[j];
+ time0 = fTime;
// Generate one event
origin[0] = iparticle->Vx();
origin[1] = iparticle->Vy();
origin[2] = iparticle->Vz();
+ time = iparticle->T();
//doubled track with freeze out coordinates for femtoscopy
PushTrack(0,
imo>=0?idsOnStack[imo]:-1,
iparticle->GetPdgCode(),
iparticle->Px(),iparticle->Py(),iparticle->Pz(),iparticle->Energy(),
origin[0], origin[1], origin[2],
- iparticle->T(),
+ time,
polar[0],polar[1],polar[2],
hasMother ? kPDecay:kPNoProcess,nt);
origin[0] += origin0[0];
origin[1] += origin0[1];
origin[2] += origin0[2];
+ time += time0;
PushTrack(1,
nt, //doubled track as mother
iparticle->GetPdgCode(),
iparticle->Px(),iparticle->Py(),iparticle->Pz(),iparticle->Energy(),
origin[0], origin[1], origin[2],
- iparticle->T(),
+ time,
polar[0],polar[1],polar[2],
kPDecay,nt);
fNprimaries++;
origin[0] = iparticle->Vx();
origin[1] = iparticle->Vy();
origin[2] = iparticle->Vz();
+ time = iparticle->T();
PushTrack(0,
imo>=0?idsOnStack[imo]:-1,
iparticle->GetPdgCode(),
iparticle->Px(),iparticle->Py(),iparticle->Pz(),iparticle->Energy(),
origin[0], origin[1], origin[2],
- iparticle->T(),
+ time,
polar[0],polar[1],polar[2],
hasMother ? kPDecay:kPNoProcess,nt);
idsOnStack[i] = nt;
header->SetNProduced(fNprimaries);
header->SetPrimaryVertex(eventVertex);
+ header->SetInteractionTime(time0);
header->SetImpactParameter(GetTEpos()->GetBimevt());
header->SetReactionPlaneAngle(GetTEpos()->GetPhievt());
// beam 1 or 2
//
Float_t ibeam = (random[1] < 0.5) ? -1. : 1.;
-
+
+ // Interaction time
+ Float_t time = origin[2]/TMath::Ccgs()*ibeam;
//
// Read next event
//
Int_t idpart = iparticle->GetPdgCode();
Int_t decayed = iparticle->GetFirstDaughter();
Int_t doTracking = fTrackIt && (decayed < 0) && (TMath::Abs(idpart) > 10);
- PushTrack(doTracking,-1,idpart,p,origin,polar,0,kPPrimary,nt);
+ PushTrack(doTracking,-1,idpart,p,origin,polar,time,kPPrimary,nt);
KeepTrack(nt);
} // track loop
nInt++;
Float_t polar[3]= {0,0,0};
//
Float_t origin[3];
+ Float_t time;
Float_t p[3];
Int_t i, j, nt;
Double_t pmom, theta, phi, pt;
Float_t random[6];
//
for (j=0;j<3;j++) origin[j]=fOrigin[j];
+ time = fTimeOrigin;
if(fVertexSmear==kPerEvent) {
Vertex();
for (j=0;j<3;j++) origin[j]=fVertex[j];
+ time = fTime;
}
Double_t m = TDatabasePDG::Instance()->GetParticle(fIpart)->Mass();
origin[j]=fOrigin[j]+fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
}
+
+ Rndm(random,2);
+ time = fTimeOrigin + fOsigma[2]/TMath::Ccgs()*
+ TMath::Cos(2*random[0]*TMath::Pi())*
+ TMath::Sqrt(-2*TMath::Log(random[1]));
}
- PushTrack(fTrackIt,-1,fIpart,p,origin,polar,0,kPPrimary,nt);
+ PushTrack(fTrackIt,-1,fIpart,p,origin,polar,time,kPPrimary,nt);
}
AliGenEventHeader* header = new AliGenEventHeader("BOX");
header->SetPrimaryVertex(fVertex);
header->SetNProduced(fNpart);
+ header->SetInteractionTime(fTime);
// Passes header either to the container or to gAlice
if (fContainer) {
AfterBurner->SetSigma(fOsigma[0], fOsigma[1], fOsigma[2]);
AfterBurner->SetVertexSmear(fVertexSmear);
AfterBurner->SetVertexSource(kContainer);
+ AfterBurner->SetTimeOrigin(fTimeOrigin);
}
AfterBurner->SetTrackingFlag(fTrackIt);
//AfterBurner->SetContainer(this);
cout << "Number of events per run" << numberOfEvents << endl;
TArrayF eventVertex;
eventVertex.Set(3 * (numberOfEvents + fNBgEvents));
+ TArrayF eventTime;
+ eventTime.Set(numberOfEvents + fNBgEvents);
fCurrentEvent=0;
//Create stacks
fInternalStacks = new TObjArray(numberOfEvents + fNBgEvents); //Create array of internal stacks
fInternalStacks->Add(stack);
Vertex();
for (Int_t j = 0; j < 3; j++) eventVertex[3 * i + j] = fVertex[j];
+ eventTime[i] = fTime;
fHeaders[i] = new AliGenCocktailEventHeader();
fCollisionGeometries[i] = 0;
}
// Set the vertex for the generator
Int_t ioff = 3 * i;
fCurrentGenerator->SetVertex(eventVertex.At(ioff), eventVertex.At(ioff + 1), eventVertex.At(ioff + 2));
+ fCurrentGenerator->SetTime(eventTime.At(i));
fHeader = fHeaders[i];
- // Set the vertex for the cocktail
+ // Set the vertex and time for the cocktail
TArrayF v(3);
for (Int_t j=0; j<3; j++) v[j] = eventVertex.At(ioff + j);
fHeader->SetPrimaryVertex(v);
+ fHeader->SetInteractionTime(eventTime.At(i));
// Generate event
fCurrentGenerator->Generate();
//
while((entry = (AliGenCocktailEntry*)next())) {
gen = entry->Generator();
gen->SetVertex(fVertex.At(0), fVertex.At(1), fVertex.At(2));
+ gen->SetTime(fTime);
if (fNPart > 0) {
igen++;
for (Int_t j=0; j < 3; j++) eventVertex[j] = fVertex[j];
fHeader->SetPrimaryVertex(eventVertex);
+ fHeader->SetInteractionTime(fTime);
gAlice->SetGenEventHeader(fHeader);
}
Double_t polar[3] = {0,0,0};
//
Double_t origin[3] = {0,0,0};
+ Double_t time = 0.;
Double_t p[4];
Float_t random[6];
Int_t i = 0, j, nt;
fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
}
+ Rndm(random,2);
+ time = fTimeOrigin + fOsigma[2]/TMath::Ccgs()*
+ TMath::Cos(2*random[0]*TMath::Pi())*
+ TMath::Sqrt(-2*TMath::Log(random[1]));
} else {
origin[0] = fVertex[0] + jparticle->Vx();
origin[1] = fVertex[1] + jparticle->Vy();
origin[2] = fVertex[2] + jparticle->Vz();
+ time = fTime + jparticle->T();
}
- Double_t tof = jparticle->T();
Int_t doTracking = fTrackIt && selected && (jparticle->TestBit(kTransportBit));
Int_t parent = jparticle->GetFirstMother();
PushTrack(doTracking, parent, idpart,
- p[0], p[1], p[2], p[3], origin[0], origin[1], origin[2], tof,
+ p[0], p[1], p[2], p[3], origin[0], origin[1], origin[2], time,
polar[0], polar[1], polar[2],
kPPrimary, nt, 1., jparticle->GetStatusCode());
AliGenEventHeader * header = new AliGenEventHeader();
header->SetNProduced(fNprimaries);
header->SetPrimaryVertex(fVertex);
+ header->SetInteractionTime(fTime);
AddHeader(header);
break;
Int_t i, j, nt;
//
Float_t o[3] = {0., 0., 0.};
+ Float_t time = 0.;
if(fVertexSmear == kPerEvent) {
Vertex();
for (j = 0;j < 3; j++) o[j] = fVertex[j];
+ time = fTime;
}
for(i = 0; i < fNpart; i++)
- PushTrack(fTrackIt, -1, fIpart, fP, o , polar, 0, kPPrimary, nt);
+ PushTrack(fTrackIt, -1, fIpart, fP, o , polar, time, kPPrimary, nt);
}
orgin[0] = fVertex[0];
orgin[1] = fVertex[1];
orgin[2] = fVertex[2];
-
+ time = fTime;
// Particle params database
TArrayF eventVertex(3,orgin);
header->SetPrimaryVertex(eventVertex);
+ header->SetInteractionTime(time);
header->SetEventPlane(fPsi);
header->SetEllipticFlow(fPhiFormula->GetParameter(2));
const Int_t kKaons[4] = {kK0Long, kK0Short, kKPlus, kKMinus};
//
Float_t origin[3];
+ Float_t time;
Float_t pt, pl, ptot, wgt;
Float_t phi, theta;
Float_t p[3];
Float_t random[6];
//
for (j=0;j<3;j++) origin[j]=fOrigin[j];
+ time = fTimeOrigin;
if(fVertexSmear == kPerEvent) {
Vertex();
for (j=0; j < 3; j++) origin[j] = fVertex[j];
+ time = fTime;
} // if kPerEvent
TArrayF eventVertex;
eventVertex.Set(3);
eventVertex[0] = origin[0];
eventVertex[1] = origin[1];
eventVertex[2] = origin[2];
+ Float_t eventTime = time;
for(i=0;i<fNpart;i++) {
while(1) {
origin[j]=fOrigin[j]+fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
}
+ Rndm(random,2);
+ time = fTimeOrigin + fOsigma[2]/TMath::Ccgs()*
+ TMath::Cos(2*random[0]*TMath::Pi())*
+ TMath::Sqrt(-2*TMath::Log(random[1]));
}
if (fAnalog == 0) {
if (part == kPi0 && fPi0Decays){
//
// Decay pi0 if requested
- PushTrack(0,-1,part,p,origin,polar,0,kPPrimary,fNt,wgt);
+ PushTrack(0,-1,part,p,origin,polar,time,kPPrimary,fNt,wgt);
KeepTrack(fNt);
- DecayPi0(origin, p);
+ DecayPi0(origin, p, time);
} else {
// printf("fNt %d", fNt);
- PushTrack(fTrackIt,-1,part,p,origin,polar,0,kPPrimary,fNt,wgt);
+ PushTrack(fTrackIt,-1,part,p,origin,polar,time,kPPrimary,fNt,wgt);
KeepTrack(fNt);
}
AliGenEventHeader* header = new AliGenEventHeader("HIJINGparam");
// Event Vertex
header->SetPrimaryVertex(eventVertex);
+ header->SetInteractionTime(eventTime);
header->SetNProduced(fNpartProd);
gAlice->SetGenEventHeader(header);
}
AliGenerator::SetPtRange(ptmin, ptmax);
}
-void AliGenHIJINGpara::DecayPi0(Float_t* orig, Float_t * p)
+void AliGenHIJINGpara::DecayPi0(Float_t* orig, Float_t * p, Float_t time)
{
//
// Decay the pi0
p[2] = iParticle->Pz();
Int_t part = iParticle->GetPdgCode();
- PushTrack(fTrackIt, fNt, part, p, orig, polar, 0, kPDecay, nt, fParentWeight);
+ PushTrack(fTrackIt, fNt, part, p, orig, polar, time, kPDecay, nt, fParentWeight);
KeepTrack(nt);
}
fNt = nt;
TF1* fETAkac; // Parametrised eta distribution fro ka
AliDecayer* fDecayer; // ! Pointer to pythia object for decays
- void DecayPi0(Float_t* orig, Float_t * p);
+ void DecayPi0(Float_t* orig, Float_t * p, Float_t time);
private:
AliGenHIJINGpara(const AliGenHIJINGpara &HIJINGpara);
const Int_t kBaryons[4] = {kProton, kProtonBar, kNeutron, kNeutronBar};
//
Float_t origin[3];
+ Float_t time;
Float_t pt, pl, ptot;
Float_t phi, theta;
Float_t p[3];
Float_t random[6];
//
for (j=0;j<3;j++) origin[j]=fOrigin[j];
+ time = fTimeOrigin;
if(fVertexSmear == kPerEvent) {
Float_t dv[3];
}
}
for (j=0; j < 3; j++) origin[j] += dv[j];
+
+ Rndm(random,2);
+ time += fOsigma[2]/TMath::Ccgs()*
+ TMath::Cos(2*random[0]*TMath::Pi())*
+ TMath::Sqrt(-2*TMath::Log(random[1]));
} // if kPerEvent
TArrayF eventVertex;
eventVertex.Set(3);
eventVertex[0] = origin[0];
eventVertex[1] = origin[1];
eventVertex[2] = origin[2];
+ Float_t eventTime = time;
for(i=0;i<fNpart;i++) {
while(1) {
origin[j]=fOrigin[j]+fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
}
+
+ Rndm(random,2);
+ time = fTimeOrigin + fOsigma[2]/TMath::Ccgs()*
+ TMath::Cos(2*random[0]*TMath::Pi())*
+ TMath::Sqrt(-2*TMath::Log(random[1]));
}
- PushTrack(fTrackIt,-1,part,p,origin,polar,0,kPPrimary,nt,fParentWeight);
+ PushTrack(fTrackIt,-1,part,p,origin,polar,time,kPPrimary,nt,fParentWeight);
break;
} // while(1)
} // Particle loop
AliGenEventHeader* header = new AliGenEventHeader("HIJINGparam");
// Event Vertex
header->SetPrimaryVertex(eventVertex);
+ header->SetInteractionTime(eventTime);
gAlice->SetGenEventHeader(header);
}
while((entry = (AliGenCocktailEntry*)next())) {
gen = entry->Generator();
gen->SetVertex(fVertex.At(0), fVertex.At(1), fVertex.At(2));
+ gen->SetTime(fTime);
if ( (npart = gRandom->Poisson(entry->Rate())) >0 ) {
igen++;
if (igen == 1) entry->SetFirst(0);
(gAlice->GetMCApp()->Particle(iPart)->Theta()*180./TMath::Pi()>fMuonThetaMinCut) &&
(gAlice->GetMCApp()->Particle(iPart)->Theta()*180./TMath::Pi()<fMuonThetaMaxCut) &&
(gAlice->GetMCApp()->Particle(iPart)->Pt()>fMuonPtCut) ) {
- gAlice->GetMCApp()->Particle(iPart)->SetProductionVertex(fVertex.At(0), fVertex.At(1), fVertex.At(2), 0.);
+ gAlice->GetMCApp()->Particle(iPart)->SetProductionVertex(fVertex.At(0), fVertex.At(1), fVertex.At(2), fTime);
GoodMuons.AddLast(gAlice->GetMCApp()->Particle(iPart));
numberOfMuons++;
}
gen = entry->Generator();
genName = entry->GetName();
gen->SetVertex(fVertex.At(0), fVertex.At(1), fVertex.At(2));
+ gen->SetTime(fTime);
npart = (strcmp(genName,"Pythia") == 0) ? 1 :
gRandom->Poisson(entry->Rate());
for (Int_t j=0; j < 3; j++) eventVertex[j] = fVertex[j];
fHeader->SetPrimaryVertex(eventVertex);
+ fHeader->SetInteractionTime(fTime);
gAlice->SetGenEventHeader(fHeader);
Int_t nmuons = -1, npartPushed = 0, pdgPushed[100];
Double_t polar[3]= {0,0,0}; // Polarisation of the parent particle (for GEANT tracking)
Double_t origin0[3]; // Origin of the generated parent particle (for GEANT tracking)
+ Double_t time0; // Time0 of the generated parent particle
// Calculating vertex position per event
for (Int_t j=0;j<3;j++) origin0[j]=fOrigin[j];
+ time0 = fTimeOrigin;
if(fVertexSmear==kPerEvent) {
Vertex();
for (Int_t j=0;j<3;j++) origin0[j]=fVertex[j];
+ time0 = fTime;
}
printf ("In Generate()\n");
if (TMath::Abs(pdgPushed[ipart]) != 13) { // particle is not a muon, hence it's a mother
PushTrack(0,-1,pdgPushed[ipart],
pxPushed[ipart],pyPushed[ipart],pzPushed[ipart],ePushed[ipart],
- origin0[0],origin0[1],origin0[2],0.,
+ origin0[0],origin0[1],origin0[2],time0,
polar[0],polar[1],polar[2],
kPPrimary,ntmother,1,11);
KeepTrack(ntmother);
else {
PushTrack(1,ntmother,pdgPushed[ipart],
pxPushed[ipart],pyPushed[ipart],pzPushed[ipart],ePushed[ipart],
- origin0[0],origin0[1],origin0[2],0.,
+ origin0[0],origin0[1],origin0[2],time0,
polar[0],polar[1],polar[2],
kPDecay,ntchild,1,1);
KeepTrack(ntchild);
SetHighWaterMark(ntchild);
AliGenEventHeader* header = new AliGenEventHeader("LMR");
header->SetPrimaryVertex(fVertex);
+ header->SetInteractionTime(fTime);
header->SetNProduced(fNprimaries);
AddHeader(header);
}
//
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 time0; // Time0 of the generated parent particle
Float_t pt, pl, ptot; // Transverse, logitudinal and total momenta of the parent particle
Float_t phi, theta; // Phi and theta spherical angles of the parent particle momentum
Float_t p[3], pc[3],
// Calculating vertex position per event
for (j=0;j<3;j++) origin0[j]=fOrigin[j];
+ time0 = fTimeOrigin;
if(fVertexSmear==kPerEvent) {
Vertex();
for (j=0;j<3;j++) origin0[j]=fVertex[j];
+ time0 = fTime;
}
Int_t ipa=0;
fOrigin[j]+fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
}
+ Rndm(random,2);
+ time0 = fTimeOrigin + fOsigma[2]/TMath::Ccgs()*
+ TMath::Cos(2*random[0]*TMath::Pi())*
+ TMath::Sqrt(-2*TMath::Log(random[1]));
}
// Looking at fForceDecay :
// Parent
- PushTrack(0, -1, iPart, p, origin0, polar, 0, kPPrimary, nt, wgtp, ((decayed)? 11 : 1));
+ PushTrack(0, -1, iPart, p, origin0, polar, time0, kPPrimary, nt, wgtp, ((decayed)? 11 : 1));
pParent[0] = nt;
KeepTrack(nt);
fNprimaries++;
PushTrack(fTrackIt * trackIt[i], iparent, kf,
pc, och, polar,
- 0, kPDecay, nt, wgtch, ksc);
+ time0 + iparticle->T(), kPDecay, nt, wgtch, ksc);
pParent[i] = nt;
KeepTrack(nt);
fNprimaries++;
else // nodecay option, so parent will be tracked by GEANT (pions, kaons, eta, omegas, baryons)
{
gAlice->GetMCApp()->
- PushTrack(fTrackIt,-1,iPart,p,origin0,polar,0,kPPrimary,nt,wgtp, 1);
+ PushTrack(fTrackIt,-1,iPart,p,origin0,polar,time0,kPPrimary,nt,wgtp, 1);
ipa++;
fNprimaries++;
}
AliGenEventHeader* header = new AliGenEventHeader("PARAM");
header->SetPrimaryVertex(fVertex);
+ header->SetInteractionTime(fTime);
header->SetNProduced(fNprimaries);
AddHeader(header);
}
Float_t polar[3]= {0,0,0};
Float_t origin[3];
+ Float_t time;
Float_t p[3];
Float_t random[6];
Int_t nt;
for (Int_t j=0;j<3;j++) origin[j]=fOrigin[j];
+ time = fTimeOrigin;
/*
if(fVertexSmear==kPerEvent) {
Vertex();
for (j=0;j<3;j++) origin[j]=fVertex[j];
+ time = fTime;
}
*/
TArrayF eventVertex;
eventVertex[0] = origin[0];
eventVertex[1] = origin[1];
eventVertex[2] = origin[2];
+ Float_t eventTime = time;
Int_t nGam;
Float_t b,pt,rapidity,phi,ww;
origin[j]=fOrigin[j]+fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
}
+ Rndm(random,2);
+ time = fTimeOrigin + fOsigma[2]/TMath::Ccgs()*
+ TMath::Cos(2*random[0]*TMath::Pi())*
+ TMath::Sqrt(-2*TMath::Log(random[1]));
}
- PushTrack(fTrackIt,-1,22,p,origin,polar,0,kPPrimary,nt,1.);
+ PushTrack(fTrackIt,-1,22,p,origin,polar,time,kPPrimary,nt,1.);
}
}
AliGenEventHeader* header = new AliGenEventHeader("PromptPhotons");
// Event Vertex
header->SetPrimaryVertex(eventVertex);
+ header->SetInteractionTime(eventTime);
header->SetNProduced(fNpart);
gAlice->SetGenEventHeader(header);
//
Float_t p[3], theta=0;
Float_t origin[3] = {0., 0., 0.};
+ Float_t time = 0.;
Float_t polar [3] = {0., 0., 0.};
Int_t nt, i, j;
Int_t kf;
if(fVertexSmear == kPerEvent) {
Vertex();
for (j=0; j < 3; j++) origin[j] = fVertex[j];
+ time = fTime;
} // if kPerEvent
//
// Gray protons
GenerateSlow(fCharge, fTemperatureG, fBetaSourceG, p, theta);
if (fDebug) fCosThetaGrayHist->Fill(TMath::Cos(theta));
PushTrack(fTrackIt, -1, kf, p, origin, polar,
- 0., kPNoProcess, nt, 1.);
+ time, kPNoProcess, nt, 1.);
KeepTrack(nt);
}
//
GenerateSlow(fCharge, fTemperatureG, fBetaSourceG, p, theta);
if (fDebug) fCosThetaGrayHist->Fill(TMath::Cos(theta));
PushTrack(fTrackIt, -1, kf, p, origin, polar,
- 0., kPNoProcess, nt, 1.);
+ time, kPNoProcess, nt, 1.);
KeepTrack(nt);
}
//
for(i = 0; i < fNbp; i++) {
GenerateSlow(fCharge, fTemperatureB, fBetaSourceB, p, theta);
PushTrack(fTrackIt, -1, kf, p, origin, polar,
- 0., kPNoProcess, nt, 1.);
+ time, kPNoProcess, nt, 1.);
KeepTrack(nt);
}
//
for(i = 0; i < fNbn; i++) {
GenerateSlow(fCharge, fTemperatureB, fBetaSourceB, p, theta);
PushTrack(fTrackIt, -1, kf, p, origin, polar,
- 0., kPNoProcess, nt, 1.);
+ time, kPNoProcess, nt, 1.);
KeepTrack(nt);
}
}
Float_t polar[3]= {0,0,0};
Float_t origin[3];
+ Float_t time;
Float_t p[3];
Float_t random[6];
Int_t nt;
for (Int_t j=0;j<3;j++) origin[j]=fOrigin[j];
+ time = fTimeOrigin;
/*
if(fVertexSmear==kPerEvent) {
Vertex();
for (j=0;j<3;j++) origin[j]=fVertex[j];
+ time = fTime;
}
*/
TArrayF eventVertex;
eventVertex[0] = origin[0];
eventVertex[1] = origin[1];
eventVertex[2] = origin[2];
+ Float_t eventTime = time;
Int_t nGam;
Float_t impPar,area,pt,rapidity,phi,ww;
origin[j]=fOrigin[j]+fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
}
+ Rndm(random,2);
+ time = fTimeOrigin + fOsigma[2]/TMath::Ccgs()*
+ TMath::Cos(2*random[0]*TMath::Pi())*
+ TMath::Sqrt(-2*TMath::Log(random[1]));
}
- PushTrack(fTrackIt,-1,22,p,origin,polar,0,kPPrimary,nt,1.);
+ PushTrack(fTrackIt,-1,22,p,origin,polar,time,kPPrimary,nt,1.);
}
}
AliGenEventHeader* header = new AliGenEventHeader("ThermalPhotons");
// Event Vertex
header->SetPrimaryVertex(eventVertex);
+ header->SetInteractionTime(eventTime);
header->SetNProduced(fNpart);
gAlice->SetGenEventHeader(header);
Float_t polar[3]= {0,0,0};
Float_t origin[3];
+ Float_t time;
Float_t p[3];
Int_t i, j, nt;
Double_t pmom, theta, phi, pt;
if (fNpart == 0) return;
for (j=0;j<3;j++) origin[j]=fOrigin[j];
+ time = fTimeOrigin;
if(fVertexSmear==kPerEvent) {
Rndm(random,6);
for (j=0;j<3;j++) {
origin[j]+=fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
}
+ Rndm(random,2);
+ time += fOsigma[2]/TMath::Ccgs()*
+ TMath::Cos(2*random[0]*TMath::Pi())*
+ TMath::Sqrt(-2*TMath::Log(random[1]));
}
Float_t thetaInterval = 0.;
if (fNpart > 1) {
origin[j]=fOrigin[j]+fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
}
+ Rndm(random,2);
+ time = fTimeOrigin + fOsigma[2]/TMath::Ccgs()*
+ TMath::Cos(2*random[0]*TMath::Pi())*
+ TMath::Sqrt(-2*TMath::Log(random[1]));
}
- PushTrack(fTrackIt,-1,fIpart,p,origin,polar,0,kPPrimary,nt);
+ PushTrack(fTrackIt,-1,fIpart,p,origin,polar,time,kPPrimary,nt);
}
}
origin[1] = fVertex[1]+iparticle->Vy()/10; // [cm]
origin[2] = fVertex[2]+iparticle->Vz()/10; // [cm]
- Float_t tof = kconv*iparticle->T();
+ Float_t tof = fTime + kconv*iparticle->T();
Int_t ipa = iparticle->GetFirstMother()-1;
Int_t iparent = (ipa > -1) ? pParent[ipa] : -1;
origin[1] = fVertex[1]+iparticle->Vy()/10; // [cm]
origin[2] = fVertex[2]+iparticle->Vz()/10; // [cm]
- Float_t tof = fEventTime + kconv * iparticle->T();
+ Float_t tof = fTime + fEventTime + kconv * iparticle->T();
PushTrack(fTrackIt*trackIt, iparent, kf,
p[0], p[1], p[2], p[3],
//
// Event Vertex
fHeader->SetPrimaryVertex(fVertex);
- fHeader->SetInteractionTime(fEventTime);
+ fHeader->SetInteractionTime(fTime+fEventTime);
//
// Number of primaries
fHeader->SetNProduced(fNprimaries);
origin[1] = fVertex[1]+iparticle->Vy()/10; // [cm]
origin[2] = fVertex[2]+iparticle->Vz()/10; // [cm]
- Float_t tof = kconv*iparticle->T();
+ Float_t tof = fTime + kconv*iparticle->T();
Int_t ipa = (fPythia->Version() == 6) ? (iparticle->GetFirstMother() - 1) :(iparticle->GetFirstMother()) ;
Int_t iparent = (ipa > -1) ? pParent[ipa] : -1;
origin[1] = fVertex[1]+iparticle->Vy()/10; // [cm]
origin[2] = fVertex[2]+iparticle->Vz()/10; // [cm]
- Float_t tof = fEventTime + kconv * iparticle->T();
+ Float_t tof = fTime + fEventTime + kconv * iparticle->T();
PushTrack(fTrackIt*trackIt, iparent, kf,
p[0], p[1], p[2], p[3],
//
// Event Vertex
fHeader->SetPrimaryVertex(fVertex);
-
+ fHeader->SetInteractionTime(fTime+fEventTime);
//
// Number of primaries
fHeader->SetNProduced(fNprimaries);
fOrigin(3),
fOsigma(3),
fVertex(3),
+ fTimeOrigin(0.),
+ fTime(0.),
fStack(0),
fContainer(0),
fCollisionGeometry(0),
fOrigin(3),
fOsigma(3),
fVertex(3),
+ fTimeOrigin(0.),
+ fTime(0.),
fStack(0),
fContainer(0),
fCollisionGeometry(0),
fVertex[0] = vertex.X();
fVertex[1] = vertex.Y();
fVertex[2] = vertex.Z();
+ fTime = 0.;
}
//_______________________________________________________________________
}
}
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 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();
TArrayF fOrigin; // Origin of event
TArrayF fOsigma; // Sigma of the Origin of event
TArrayF fVertex; //! Vertex of current event
+
+ Float_t fTimeOrigin; // Time0 origin in a run or event sample
+ Float_t fTime; // Event time smeared around time0 origin using sigma vertex
AliStack* fStack; //! Local pointer to stack
AliGenerator* fContainer; //! Local pointer to container
AliGenerator(const AliGenerator &gen);
AliGenerator & operator=(const AliGenerator &gen);
- ClassDef(AliGenerator,4) // Base class for event generators
+ ClassDef(AliGenerator,5) // Base class for event generators
};
#endif
origin[1] = fVertex[1]+iparticle->Vy()/10; // [cm]
origin[2] = fVertex[2]+iparticle->Vz()/10; // [cm]
- tof = kconv*iparticle->T();
+ tof = fTime + kconv*iparticle->T();
imo = -1;
TParticle* mother = 0;
((AliGenDPMjetEventHeader*) header)->SetTrials(fTrials);
// Event Vertex
header->SetPrimaryVertex(fVertex);
+ header->SetInteractionTime(fTime);
gAlice->SetGenEventHeader(header);
AddHeader(header);
}
Float_t polar[3]= {0,0,0};
Float_t origin[3];
+ Float_t time = 0.;
Float_t p[3];
Double_t ptElectron,ptPositron, phiElectron,phiPositron, mt;
yElectron,yPositron,xElectron,xPositron,phi12);
for (j=0;j<3;j++) origin[j]=fOrigin[j];
+ time = fTimeOrigin;
if(fVertexSmear==kPerEvent) {
Rndm(random,6);
for (j=0;j<3;j++) {
origin[j]+=fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
}
+ Rndm(random,2);
+ time += fOsigma[2]/TMath::Ccgs()*
+ TMath::Cos(2*random[0]*TMath::Pi())*
+ TMath::Sqrt(-2*TMath::Log(random[1]));
}
Rndm(random,1);
id = 11;
if (fDebug == 2)
printf("id=%+3d, p = (%+11.4e,%+11.4e,%+11.4e) GeV\n",id,p[0],p[1],p[2]);
- PushTrack(fTrackIt,-1, id,p,origin,polar,0,kPPrimary,nt,weight);
+ PushTrack(fTrackIt,-1, id,p,origin,polar,time,kPPrimary,nt,weight);
// Produce positron
mt = TMath::Sqrt(ptPositron*ptPositron + fMass*fMass);
id = -11;
if (fDebug == 2)
printf("id=%+3d, p = (%+11.4e,%+11.4e,%+11.4e) GeV\n",id,p[0],p[1],p[2]);
- PushTrack(fTrackIt,-1, id,p,origin,polar,0,kPPrimary,nt,weight);
+ PushTrack(fTrackIt,-1, id,p,origin,polar,time,kPPrimary,nt,weight);
fEvent++;
if (fEvent%1000 == 0) {
fEvent,fEpEmGen->GetXsection(),fEpEmGen->GetDsection());
}
fHeader.SetEventWeight(weight);
+ fHeader.SetInteractionTime(time);
AddHeader(&fHeader);
}
origin[1] = fVertex[1] + iparticle->Vy()/10; // [cm]
origin[2] = fVertex[2] + iparticle->Vz()/10; // [cm]
- Float_t tof = kconv*iparticle->T();
+ Float_t tof = fTime + kconv*iparticle->T();
Int_t iparent = (imo > -1) ? newPos[imo] : -1;
Int_t trackIt = (ks == 1) && fTrackIt;
PushTrack(trackIt, iparent, kf,
//
// Event Vertex
fHeader->SetPrimaryVertex(fVertex);
-
+ fHeader->SetInteractionTime(fTime);
//
// Number of primaries
fHeader->SetNProduced(fNprimaries);
fLHC(kFALSE),
fRandomPz(kFALSE),
fNoHeavyQuarks(kFALSE),
- fEventTime(0.),
fHeader(AliGenHijingEventHeader("Hijing"))
{
// Constructor
fLHC(kFALSE),
fRandomPz(kFALSE),
fNoHeavyQuarks(kFALSE),
- fEventTime(0.),
fHeader(AliGenHijingEventHeader("Hijing"))
{
// Default PbPb collisions at 5. 5 TeV
Float_t polar[3] = {0,0,0};
Float_t origin[3] = {0,0,0};
Float_t origin0[3] = {0,0,0};
+ Float_t time0 = 0.;
Float_t p[3];
Float_t tof;
fTrials = 0;
for (j = 0;j < 3; j++) origin0[j] = fOrigin[j];
+ time0 = fTimeOrigin;
if(fVertexSmear == kPerEvent) {
Vertex();
for (j=0; j < 3; j++) origin0[j] = fVertex[j];
+ time0 = fTime;
}
fVertex[0] = origin0[0];
fVertex[1] = origin0[1];
fVertex[2] = origin0[2];
-
+ fTime = time0;
//
// First select parent particles
//
} // selected
} // particle loop final state
-//
-// Time of the interactions
- Float_t tInt = 0.;
- if (fPileUpTimeWindow > 0.) tInt = fPileUpTimeWindow * (2. * gRandom->Rndm() - 1.);
-
//
// Write particles to stack
origin[0] = origin0[0]+iparticle->Vx()/10;
origin[1] = origin0[1]+iparticle->Vy()/10;
origin[2] = origin0[2]+iparticle->Vz()/10;
- fEventTime = 0.;
-
- if (TestBit(kVertexRange)) {
- fEventTime = sign * origin0[2] / 2.99792458e10;
- tof = kconv * iparticle->T() + fEventTime;
- } else {
- tof = kconv * iparticle->T();
- fEventTime = tInt;
- if (fPileUpTimeWindow > 0.) tof += tInt;
- }
+ tof = time0+kconv * iparticle->T();
+
imo = -1;
TParticle* mother = 0;
if (hasMother) {
fHeader.SetTrials(fTrials);
// Event Vertex
fHeader.SetPrimaryVertex(fVertex);
- fHeader.SetInteractionTime(fEventTime);
+ fHeader.SetInteractionTime(fTime);
AddHeader(&fHeader);
fCollisionGeometry = &fHeader;
}
Int_t fLHC; // Assume LHC as lab frame
Bool_t fRandomPz; // Randomise sign of pz event by event
Bool_t fNoHeavyQuarks; // If true no heavy quarks are produced
- Float_t fEventTime; // The event time
AliGenHijingEventHeader fHeader; // MC Header
private:
// check if stable
Bool_t Stable(const TParticle* particle) const;
- ClassDef(AliGenHijing, 7) // AliGenerator interface to Hijing
+ ClassDef(AliGenHijing, 8) // AliGenerator interface to Hijing
};
#endif
Float_t polar[3] = {0,0,0};
Float_t origin[3] = {0,0,0};
Float_t origin0[3] = {0,0,0};
+ Float_t time0 = 0.;
Float_t p[3];
Float_t tof;
kf = 0;
for (j = 0;j < 3; j++) origin0[j] = fOrigin[j];
+ time0 = fTimeOrigin;
if(fVertexSmear == kPerEvent) {
Vertex();
for (j=0; j < 3; j++) origin0[j] = fVertex[j];
+ time0 = fTime;
}
while(1)
fVertex[0] = origin0[0];
fVertex[1] = origin0[1];
fVertex[2] = origin0[2];
+ fTime = time0;
//
// Now select the final state particles
origin[0] = fVertex[0]+iparticle->Vx()/10;
origin[1] = fVertex[1]+iparticle->Vy()/10;
origin[2] = fVertex[2]+iparticle->Vz()/10;
- tof = kconv*iparticle->T();
+ tof = fTime + kconv*iparticle->T();
imo = -1;
//imo = iparticle->GetFirstMother();
// Event Vertex
header->SetPrimaryVertex(fVertex);
+ header->SetInteractionTime(fTime);
AddHeader(header);
fCollisionGeometry = (AliGenHydjetEventHeader*) header;
}
Float_t polar[3] = {0,0,0};
Float_t origin0[3] = {0,0,0};
+ Float_t time0 = 0.;
Float_t origin[3] = {0,0,0};
Float_t p[3], tof;
Double_t weight;
Info("Generate()","one event is produced");
Int_t j;
- for (j=0;j<3;j++) origin[j]=fOrigin[j];
+ for (j=0;j<3;j++) origin0[j]=fOrigin[j];
+ time0 = fTimeOrigin;
if(fVertexSmear==kPerEvent) {
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,2);
+ time0 += fOsigma[2]/TMath::Ccgs()*
+ TMath::Cos(2*random[0]*TMath::Pi())*
+ TMath::Sqrt(-2*TMath::Log(random[1]));
}
Int_t ip;
origin[2] = origin0[2]+iparticle->Vz()/10.;
kf = CheckPDGCode(iparticle->GetPdgCode());
iparent = -1;
- tof = kconv*iparticle->T();
+ tof = time0 + kconv*iparticle->T();
if (ks == 1) trackIt = 1;
else trackIt = 0;
PushTrack(fTrackIt*trackIt,iparent,kf,p,origin,polar,tof,kPPrimary,nt,weight,ks);
Float_t polar[3] = {0,0,0};
Float_t origin[3] = {0,0,0};
+ Float_t time = 0.;
Float_t origin0[3] = {0,0,0};
+ Float_t time0 = 0.;
Float_t p[3];
Float_t mass, energy;
Vertex();
for (j=0; j < 3; j++) origin0[j] = fVertex[j];
+ time0 = fTime;
// Generate one event
origin[0] = vrho*TMath::Cos(vphi + evrot);
origin[1] = vrho*TMath::Sin(vphi + evrot);
origin[2] = iparticle->Vz();
-
+ time = iparticle->T();
+
imo = -1;
// TParticle* mother = 0;
if (hasMother) {
// printf("Pushing Track %d with status %d mother %d\n", kf, tFlag, imo>=0?idsOnStack[imo]:imo);
PushTrack(tFlag,imo>=0?idsOnStack[imo]:imo,kf,
p[0],p[1],p[2],energy,
- origin[0],origin[1],origin[2],iparticle->T(),
+ origin[0],origin[1],origin[2],time,
polar[0],polar[1],polar[2],
hasMother ? kPDecay:kPNoProcess,nt);
idsOnStack[i] = nt;
origin[0] = vrho*TMath::Cos(vphi + evrot);
origin[1] = vrho*TMath::Sin(vphi + evrot);
origin[2] = iparticle->Vz();
-
+ time = iparticle->T();
+
imo = -1;
// TParticle* mother = 0;
if (hasMother) {
// printf("Pushing Track %d with status %d mother %d\n", kf, tFlag, imo>=0?idsOnStack[imo]:imo);
PushTrack(tFlag,imo>=0?idsOnStack[imo]:imo,kf,
p[0],p[1],p[2],energy,
- origin[0],origin[1],origin[2],iparticle->T(),
+ origin[0],origin[1],origin[2],time,
polar[0],polar[1],polar[2],
hasMother ? kPDecay:kPNoProcess,nt);
idsOnStack[i] = nt;
origin[0] = origin0[0]+vrho*TMath::Cos(vphi + evrot);
origin[1] = origin0[1]+vrho*TMath::Sin(vphi + evrot);
origin[2] = origin0[2]+iparticle->Vz();
+ time = time0+iparticle->T();
imo = nt;
// mother = (TParticle *) fParticles.At(nt);
// printf("Pushing Track %d with status %d mother %d\n", kf, tFlag, imo);
PushTrack(tFlag,imo,kf,
p[0],p[1],p[2],energy,
- origin[0],origin[1],origin[2],iparticle->T(),
+ origin[0],origin[1],origin[2],time,
polar[0],polar[1],polar[2],
hasMother ? kPDecay:kPNoProcess,nt);
fNprimaries++;
eventVertex[0] = origin0[0];
eventVertex[1] = origin0[1];
eventVertex[2] = origin0[2];
+ Float_t eventTime = time0;
// Builds the event header, to be called after each event
AliGenEventHeader* header = new AliGenHijingEventHeader("Therminator");
((AliGenHijingEventHeader*) header)->SetNProduced(fNprimaries);
((AliGenHijingEventHeader*) header)->SetPrimaryVertex(eventVertex);
+ ((AliGenHijingEventHeader*) header)->SetInteractionTime(eventTime);
((AliGenHijingEventHeader*) header)->SetImpactParameter(0.0);
((AliGenHijingEventHeader*) header)->SetTotalEnergy(0.0);
((AliGenHijingEventHeader*) header)->SetHardScatters(0);
// ((AliGenHijingEventHeader*) header)->SetTrials(fTrials);
// Event Vertex
header->SetPrimaryVertex(fVertex);
+ header->SetInteractionTime(fTime);
AddHeader(header);
fCollisionGeometry = (AliGenHijingEventHeader*) header;
Float_t polar[3] = {0,0,0};
Float_t origin[3] = {0,0,0};
Float_t origin0[3] = {0,0,0};
+ Float_t time0 = 0.;
Float_t p[3];
Float_t v[3];
Float_t mass=0.0, energy=0.0;
Vertex();
for(Int_t j=0; j<3; j++) origin0[j] = fVertex[j];
+ time0 = fTime;
// Generate the event and import particles
fUHKMgen->GenerateEvent();
origin[0] = origin0[0]+v[0];
origin[1] = origin0[1]+v[1];
origin[2] = origin0[2]+v[2];
+ Float_t time = time0+iparticle->T();
imo = nt;
trackFlag = fTrackIt; // Track this particle, unless otherwise specified by fTrackIt
PushTrack(trackFlag, imo, kf,
p[0], p[1], p[2], energy,
- origin[0], origin[1], origin[2], iparticle->T(),
+ origin[0], origin[1], origin[2], time,
polar[0], polar[1], polar[2],
hasMother ? kPDecay:kPNoProcess, nt);
eventVertex[0] = origin0[0];
eventVertex[1] = origin0[1];
eventVertex[2] = origin0[2];
+ Float_t eventTime = time0;
// Builds the event header, to be called after each event
AliGenEventHeader* header = new AliGenHijingEventHeader("UHKM");
((AliGenHijingEventHeader*) header)->SetNProduced(fNprimaries);
((AliGenHijingEventHeader*) header)->SetPrimaryVertex(eventVertex);
+ ((AliGenHijingEventHeader*) header)->SetInteractionTime(eventTime);
((AliGenHijingEventHeader*) header)->SetImpactParameter(b);
((AliGenHijingEventHeader*) header)->SetTotalEnergy(0.0);
((AliGenHijingEventHeader*) header)->SetHardScatters(0);
((AliGenHijingEventHeader*) header)->SetReactionPlaneAngle(0);//evrot);
header->SetPrimaryVertex(fVertex);
+ header->SetInteractionTime(fTime);
AddHeader(header);
fCollisionGeometry = (AliGenHijingEventHeader*) header;