TLorentzVector mom;
static Float_t hits[14];
- Int_t tracknumber = gAlice->CurrentTrack();
+ Int_t tracknumber = gAlice->GetCurrentTrackNumber();
static Float_t eloss;
static Float_t tlength;
hits[12] = tlength; // Trajectory lenght
hits[13] = (Float_t)tracknumber;
- AddHit(gAlice->CurrentTrack(),vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(),vol, hits);
}
hits[12] = 0;
hits[13] = 0;
- //hits[9] = gAlice->CurrentTrack();
+ //hits[9] = gAlice->GetCurrentTrackNumber();
- AddHit(gAlice->CurrentTrack(),vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(),vol, hits);
eloss = 0.;
//hits[10] = 1;
- //AddHit(gAlice->CurrentTrack(),vol, hits);
+ //AddHit(gAlice->GetCurrentTrackNumber(),vol, hits);
//eloss = 0.;
hits[12] = 0;
hits[13] = 0;
- AddHit(gAlice->CurrentTrack(),vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(),vol, hits);
//eloss = 0.;
hits[12] = 1;
hits[13] = 0;
- AddHit(gAlice->CurrentTrack(),vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(),vol, hits);
//eloss = 0.;
hits[13] = 1;
- AddHit(gAlice->CurrentTrack(),vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(),vol, hits);
//eloss = 0.;
}
// Put the track on the stack.
- SetTrack(fTrackIt,-1,fIpart,p,origin,polar,0,kPPrimary,nt);
+ PushTrack(fTrackIt,-1,fIpart,p,origin,polar,0,kPPrimary,nt);
}
Float_t pmom[4]={0.,0.,0.,0.};
TLorentzVector pos; // Lorentz vector of the track current position.
TLorentzVector mom; // Lorentz vector of the track current momentum.
- Int_t tracknumber = gAlice->CurrentTrack();
+ Int_t tracknumber = gAlice->GetCurrentTrackNumber();
Int_t primary = 0;
static Int_t iparent = 0;
static Float_t ienergy = 0;
Int_t idpart = iparticle->GetPdgCode();
Int_t decayed = iparticle->GetFirstDaughter();
Int_t doTracking = fTrackIt && (decayed < 0) && (TMath::Abs(idpart) > 10);
- SetTrack(doTracking,-1,idpart,p,origin,polar,0,kPPrimary,nt);
+ PushTrack(doTracking,-1,idpart,p,origin,polar,0,kPPrimary,nt);
KeepTrack(nt);
} // track loop
nInt++;
TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
}
}
- SetTrack(fTrackIt,-1,fIpart,p,origin,polar,0,kPPrimary,nt);
+ PushTrack(fTrackIt,-1,fIpart,p,origin,polar,0,kPPrimary,nt);
}
}
mech = AliGenCocktailAfterBurner::IntToMCProcess(p->GetUniqueID());
weight = p->GetWeight();
- gAlice->SetTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
+ gAlice->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
polx, poly, polz, mech, ntr, weight);
}
}
p[0] = pmom*TMath::Cos(phi)*TMath::Sin(theta);
p[1] = pmom*TMath::Sin(phi)*TMath::Sin(theta);
p[2] = pmom*TMath::Cos(theta);
- SetTrack(fTrackIt,-1,fIpart,p,origin,polar,0,kPPrimary,nt);
+ PushTrack(fTrackIt,-1,fIpart,p,origin,polar,0,kPPrimary,nt);
//
// Generate 2nd particle at distance fDistance from the first
//
p[0] = pmom*TMath::Cos(phi)*TMath::Sin(theta);
p[1] = pmom*TMath::Sin(phi)*TMath::Sin(theta);
p[2] = pmom*TMath::Cos(theta);
- SetTrack(fTrackIt,-1,fIpart,p,origin,polar,0,kPPrimary,nt);
+ PushTrack(fTrackIt,-1,fIpart,p,origin,polar,0,kPPrimary,nt);
}
}
}
(TMath::Abs(idpart) > 10) && selected;
// printf("*** pdg, first daughter, trk = %d, %d, %d\n",
// idpart,decayed, doTracking);
- //PH SetTrack(doTracking,-1,idpart,p,origin,polar,0,kPPrimary,nt);
+ //PH PushTrack(doTracking,-1,idpart,p,origin,polar,0,kPPrimary,nt);
Int_t parent = iparticle->GetFirstMother();
- SetTrack(doTracking,parent,idpart,p,origin,polar,0,kPPrimary,nt);
+ PushTrack(doTracking,parent,idpart,p,origin,polar,0,kPPrimary,nt);
KeepTrack(nt);
} // track loop
if (part==1 && iwgt>100) iwgt=100;
Int_t nstack=0;
for (j=0; j<iwgt; j++) {
- SetTrack(fTrackIt,-1,part,p,origin,polar,fAge,kPPrimary,nt);
+ PushTrack(fTrackIt,-1,part,p,origin,polar,fAge,kPPrimary,nt);
Rndm(random,2);
phi=2*random[1]*TMath::Pi();
Float_t pn1=p[0]*TMath::Sin(phi) - p[1]*TMath::Cos(phi);
Int_t i, nt;
//
for(i=0;i<fNpart;i++)
- SetTrack(fTrackIt,-1,fIpart,fP,fOrigin.GetArray(),polar,0,kPPrimary,nt);
+ PushTrack(fTrackIt,-1,fIpart,fP,fOrigin.GetArray(),polar,0,kPPrimary,nt);
}
//_____________________________________________________________________________
// putting particle on the stack
- SetTrack(fTrackIt, kParent, pdg, p, orgin, polar, time, kPPrimary, id, fTrackIt);
+ PushTrack(fTrackIt, kParent, pdg, p, orgin, polar, time, kPPrimary, id, fTrackIt);
if (isMultTotal) nParticle++;
}
}
if (part == kPi0 && fPi0Decays){
//
// Decay pi0 if requested
- SetTrack(0,-1,part,p,origin,polar,0,kPPrimary,fNt,fParentWeight);
+ PushTrack(0,-1,part,p,origin,polar,0,kPPrimary,fNt,fParentWeight);
KeepTrack(fNt);
DecayPi0(origin, p);
} else {
- SetTrack(fTrackIt,-1,part,p,origin,polar,0,kPPrimary,fNt,fParentWeight);
+ PushTrack(fTrackIt,-1,part,p,origin,polar,0,kPPrimary,fNt,fParentWeight);
KeepTrack(fNt);
}
p[2] = iParticle->Pz();
Int_t part = iParticle->GetPdgCode();
- SetTrack(fTrackIt, fNt, part, p, orig, polar, 0, kPDecay, nt, fParentWeight);
+ PushTrack(fTrackIt, fNt, part, p, orig, polar, 0, kPDecay, nt, fParentWeight);
KeepTrack(nt);
}
fNt = nt;
TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
}
}
- SetTrack(fTrackIt,-1,part,p,origin,polar,0,kPPrimary,nt,fParentWeight);
+ PushTrack(fTrackIt,-1,part,p,origin,polar,0,kPPrimary,nt,fParentWeight);
break;
} // while(1)
} // Particle loop
p[1]=p0*ty;
p[2]=p0*tz;
fParentWeight=wgt;
- SetTrack(fTrackIt,-1,ipart,p,origin,polar,0,kPNoProcess,nt,fParentWeight);
-// SetTrack(fTrackIt,-1,ipart,p,origin,polar,0,"Halo+",nt,fParentWeight);
+ PushTrack(fTrackIt,-1,ipart,p,origin,polar,0,kPNoProcess,nt,fParentWeight);
+// PushTrack(fTrackIt,-1,ipart,p,origin,polar,0,"Halo+",nt,fParentWeight);
origin[2]=-origin[2];
p[2]=-p[2];
- SetTrack(fTrackIt,-1,ipart,p,origin,polar,0,kPNoProcess,nt,fParentWeight);
-// SetTrack(fTrackIt,-1,ipart,p,origin,polar,0,"Halo-",nt,fParentWeight);
+ PushTrack(fTrackIt,-1,ipart,p,origin,polar,0,kPNoProcess,nt,fParentWeight);
+// PushTrack(fTrackIt,-1,ipart,p,origin,polar,0,"Halo-",nt,fParentWeight);
origin[2]=-origin[2];
p[2]=-p[2];
}
if (!fAnalog || gRandom->Rndm() < fParentWeight) {
// Pass parent particle
//
- SetTrack(0,-1,kProton,pP,originP,polar,t,kPNoProcess,ntP, fParentWeight);
+ PushTrack(0,-1,kProton,pP,originP,polar,t,kPNoProcess,ntP, fParentWeight);
KeepTrack(ntP);
- SetTrack(fTrackIt,ntP,ipart[nprim],p,origin,polar,t,kPNoProcess,nt,fParentWeight);
+ PushTrack(fTrackIt,ntP,ipart[nprim],p,origin,polar,t,kPNoProcess,nt,fParentWeight);
}
//
origin[2] = -origin[2];
originP[2] = -originP[2];
p[2]=-p[2];
- SetTrack(0,-1,kProton,pP,originP,polar,t,kPNoProcess,ntP, fParentWeight);
+ PushTrack(0,-1,kProton,pP,originP,polar,t,kPNoProcess,ntP, fParentWeight);
KeepTrack(ntP);
- SetTrack(fTrackIt,ntP,ipart[nprim],p,origin,polar,t,kPNoProcess,nt,fParentWeight);
+ PushTrack(fTrackIt,ntP,ipart[nprim],p,origin,polar,t,kPNoProcess,nt,fParentWeight);
}
}
SetHighWaterMark(nt);
ipa++;
//
// Parent
- SetTrack(0, -1, iPart, p, origin0, polar, 0, kPPrimary, nt, wgtp);
+ PushTrack(0, -1, iPart, p, origin0, polar, 0, kPPrimary, nt, wgtp);
pParent[0] = nt;
KeepTrack(nt);
//
iparent = -1;
}
- SetTrack(fTrackIt*trackIt[i], iparent, kf,
+ PushTrack(fTrackIt*trackIt[i], iparent, kf,
pc, och, polar,
0, kPDecay, nt, wgtch);
pParent[i] = nt;
else // nodecay option, so parent will be tracked by GEANT (pions, kaons, eta, omegas, baryons)
{
gAlice->
- SetTrack(fTrackIt,-1,iPart,p,origin0,polar,0,kPPrimary,nt,wgtp);
+ PushTrack(fTrackIt,-1,iPart,p,origin0,polar,0,kPPrimary,nt,wgtp);
ipa++;
}
break;
p[0] = pmom*TMath::Cos(phi)*TMath::Sin(theta);
p[1] = pmom*TMath::Sin(phi)*TMath::Sin(theta);
p[2] = pmom*TMath::Cos(theta);
- SetTrack(fTrackIt,-1,fIpart,p,origin,polar,0,kPPrimary,nt);
+ PushTrack(fTrackIt,-1,fIpart,p,origin,polar,0,kPPrimary,nt);
}
}
}
kf = kProton;
for(i = 0; i < fNgp; i++) {
GenerateSlow(fCharge, fTemperatureG, fBetaSourceG, p);
- SetTrack(fTrackIt, -1, kf, p, origin, polar,
+ PushTrack(fTrackIt, -1, kf, p, origin, polar,
0., kPNoProcess, nt, 1.);
KeepTrack(nt);
}
kf = kNeutron;
for(i = 0; i < fNgn; i++) {
GenerateSlow(fCharge, fTemperatureG, fBetaSourceG, p);
- SetTrack(fTrackIt, -1, kf, p, origin, polar,
+ PushTrack(fTrackIt, -1, kf, p, origin, polar,
0., kPNoProcess, nt, 1.);
KeepTrack(nt);
}
kf = kProton;
for(i = 0; i < fNbp; i++) {
GenerateSlow(fCharge, fTemperatureB, fBetaSourceB, p);
- SetTrack(fTrackIt, -1, kf, p, origin, polar,
+ PushTrack(fTrackIt, -1, kf, p, origin, polar,
0., kPNoProcess, nt, 1.);
KeepTrack(nt);
}
kf = kNeutron;
for(i = 0; i < fNbn; i++) {
GenerateSlow(fCharge, fTemperatureB, fBetaSourceB, p);
- SetTrack(fTrackIt, -1, kf, p, origin, polar,
+ PushTrack(fTrackIt, -1, kf, p, origin, polar,
0., kPNoProcess, nt, 1.);
KeepTrack(nt);
}
TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
}
}
- SetTrack(fTrackIt,-1,fIpart,p,origin,polar,0,kPPrimary,nt);
+ PushTrack(fTrackIt,-1,fIpart,p,origin,polar,0,kPPrimary,nt);
}
}
gMC->IsTrackStop())
{
hits[6]=de+1000.*gMC->Edep();
- new(lhits[fNhits++]) AliFMDhit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+ new(lhits[fNhits++]) AliFMDhit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
} // IsTrackExiting()
}
}
gMC->IsTrackStop())
{
hits[6]=de+1000.*gMC->Edep();
- new(lhits[fNhits++]) AliFMDhit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+ new(lhits[fNhits++]) AliFMDhit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
} // IsTrackExiting()
}
}
hits[5]=momentum[2];
hits[6]=gMC->Edep();
hits[7]=gMC->TrackTime();
- new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+ new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
*/
}
hits[6]=gMC->Edep();
hits[7]=gMC->TrackTime();
// Fill hit structure with this new hit.
- new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+ new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
return;
}
hits[6]=gMC->Edep();
hits[7]=gMC->TrackTime();
// Fill hit structure with this new hit.
- new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+ new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
return;
}
hits[6]=gMC->Edep();
hits[7]=gMC->TrackTime();
// Fill hit structure with this new hit.
- new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+ new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
return;
}
copy = fTrackReferences->GetEntriesFast();
TClonesArray &lTR = *fTrackReferences;
// Fill TrackReference structure with this new TrackReference.
- new(lTR[copy]) AliTrackReference(gAlice->CurrentTrack());
+ new(lTR[copy]) AliTrackReference(gAlice->GetCurrentTrackNumber());
} // if Outer ITS mother Volume
if(!(this->IsActive())){
return;
return;
} // end if IsEntering
// Fill hit structure with this new hit.
- new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->CurrentTrack(),vol,
+ new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,
gMC->Edep(),gMC->TrackTime(),position,
position0,momentum);
//
copy = fTrackReferences->GetEntriesFast();
TClonesArray &lTR = *fTrackReferences;
// Fill TrackReference structure with this new TrackReference.
- new(lTR[copy]) AliTrackReference(gAlice->CurrentTrack());
+ new(lTR[copy]) AliTrackReference(gAlice->GetCurrentTrackNumber());
} // if Outer ITS mother Volume
if(!(this->IsActive())){
return;
stat0 = vol[3];
} // end if IsEntering
// Fill hit structure with this new hit.
-// new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->CurrentTrack(),vol,hits);
- new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->CurrentTrack(),vol,
+// new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
+ new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,
gMC->Edep(),gMC->TrackTime(),position,
position0,momentum);
//
hits[5]=momentum[2];
hits[6]=gMC->Edep();
hits[7]=gMC->TrackTime();
-// new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+// new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
//
// no hits for this coarse asymmetric version.
//
hits[5]=momentum[2];
hits[6]=gMC->Edep();
hits[7]=gMC->TrackTime();
-// new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+// new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
//
// no hits for this coarse symmetric version.
//
copy = fTrackReferences->GetEntriesFast();
TClonesArray &lTR = *fTrackReferences;
// Fill TrackReference structure with this new TrackReference.
- new(lTR[copy]) AliTrackReference(gAlice->CurrentTrack());
+ new(lTR[copy]) AliTrackReference(gAlice->GetCurrentTrackNumber());
} // if Outer ITS mother Volume
if(!(this->IsActive())){
return;
return;
} // end if IsEntering
// Fill hit structure with this new hit only for non-entrerance hits.
- else new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->CurrentTrack(),vol,
+ else new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,
gMC->Edep(),gMC->TrackTime(),position,
position0,momentum);
//
hits[6]=gMC->Edep();
hits[7]=gMC->TrackTime();
// Fill hit structure with this new hit.
- new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+ new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
return;
}
}
new(lhits[fNhits++])
- AliMUONHit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+ AliMUONHit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
eloss = 0;
//
// Check additional signal generation conditions
hits[13] = mom[2]; // Pz
hits[14] = gMC->TrackTime(); // time of flight
new(lhits[fNhits++])
- AliMUONHit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+ AliMUONHit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
}
// if( gMC->IsTrackExiting()) gMC->StopTrack();
destep = gMC->Edep();
step = gMC->TrackStep();
//new hit
- AddHit(fIshunt, gAlice->CurrentTrack(), iChamber, ipart,
+ AddHit(fIshunt, gAlice->GetCurrentTrackNumber(), iChamber, ipart,
pos.X(), pos.Y(), pos.Z(), tof, mom.P(),
theta, phi, step, destep);
}
// new hit
new(lhits[fNhits++])
- AliMUONHit(fIshunt, gAlice->CurrentTrack(), vol,hits);
+ AliMUONHit(fIshunt, gAlice->GetCurrentTrackNumber(), vol,hits);
eloss = 0;
//
// Check additional signal generation conditions
step = gMC->TrackStep();
//new hit
if (destep>0.) new(lhits[fNhits++])
- AliMUONHit(fIshunt, gAlice->CurrentTrack(), iChamber, ipart,
+ AliMUONHit(fIshunt, gAlice->GetCurrentTrackNumber(), iChamber, ipart,
pos.X(), pos.Y(), pos.Z(), tof, mom.P(),
theta, phi, step, destep);
}
Bool_t entered = kFALSE ;
Int_t copy ;
- Int_t tracknumber = gAlice->CurrentTrack() ;
- Int_t primary = gAlice->GetPrimary( gAlice->CurrentTrack() );
+ Int_t tracknumber = gAlice->GetCurrentTrackNumber() ;
+ Int_t primary = gAlice->GetPrimary( gAlice->GetCurrentTrackNumber() );
TString name = GetGeometry()->GetName() ;
Int_t trackpid = 0 ;
TLorentzVector pos ; // Lorentz vector of the track current position
Int_t copy ;
- Int_t tracknumber = gAlice->CurrentTrack() ;
- Int_t primary = gAlice->GetPrimary( gAlice->CurrentTrack() );
+ Int_t tracknumber = gAlice->GetCurrentTrackNumber() ;
+ Int_t primary = gAlice->GetPrimary( gAlice->GetCurrentTrackNumber() );
TString name = GetGeometry()->GetName() ;
Int_t moduleNumber ;
if (xyzd[1] > GetGeometry()->GetCrystalSize(1)/2-0.002 ||
xyzd[1] < -GetGeometry()->GetCrystalSize(1)/2+0.002) {
TParticle * part = 0 ;
- Int_t parent = gAlice->CurrentTrack() ;
+ Int_t parent = gAlice->GetCurrentTrackNumber() ;
while ( parent != -1 ) {
part = gAlice->Particle(parent) ;
part->SetBit(kKeepBit);
Int_t copy ;
Float_t fLightYield ; // Light Yield per GeV
- Int_t tracknumber = gAlice->CurrentTrack() ;
- Int_t primary = gAlice->GetPrimary( gAlice->CurrentTrack() );
+ Int_t tracknumber = gAlice->GetCurrentTrackNumber() ;
+ Int_t primary = gAlice->GetPrimary( gAlice->GetCurrentTrackNumber() );
TString name = GetGeometry()->GetName() ;
Float_t lostenergy ;
Float_t global[3] ;
{
// Only verifies if the particle reaches PHOS and stops the tracking
- Int_t primary = gAlice->GetPrimary( gAlice->CurrentTrack() );
+ Int_t primary = gAlice->GetPrimary( gAlice->GetCurrentTrackNumber() );
TLorentzVector lv ;
gMC->TrackPosition(lv) ;
TLorentzVector pos ; // Lorentz vector of the track current position
Int_t copy ;
- Int_t tracknumber = gAlice->CurrentTrack() ;
- Int_t primary = gAlice->GetPrimary( gAlice->CurrentTrack() );
+ Int_t tracknumber = gAlice->GetCurrentTrackNumber() ;
+ Int_t primary = gAlice->GetPrimary( gAlice->GetCurrentTrackNumber() );
TString name = GetGeometry()->GetName() ;
// Add impact to EMC
gMC->Gdtom(center,hits,1);
hits[3] = destep*1e9; //Number in eV
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
}
}
gMC->Gdtom(center,hits,1);
hits[3] = destep*1e9; //Number in eV
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
}
}
Float_t tof = kconv*iparticle->T();
Int_t ipa = iparticle->GetFirstMother()-1;
Int_t iparent = (ipa > -1) ? pParent[ipa] : -1;
- SetTrack(fTrackIt*trackIt[i] ,
+ PushTrack(fTrackIt*trackIt[i] ,
iparent, kf, p, origin, polar, tof, kPPrimary, nt, 1., ks);
pParent[i] = nt;
KeepTrack(nt);
- } // SetTrack loop
+ } // PushTrack loop
}
} else {
nc = GenerateMB();
origin[1] = fOrigin[1]+iparticle->Vy()/10.;
origin[2] = fOrigin[2]+iparticle->Vz()/10.;
Float_t tof=kconv*iparticle->T();
- SetTrack(fTrackIt*trackIt, iparent, kf, p, origin, polar,
+ PushTrack(fTrackIt*trackIt, iparent, kf, p, origin, polar,
tof, kPPrimary, nt, 1., ks);
KeepTrack(nt);
pParent[i] = nt;
origin[1] = fOrigin[1]+iparticle->Vy()/10.;
origin[2] = fOrigin[2]+iparticle->Vz()/10.;
Float_t tof=kconv*iparticle->T();
- SetTrack(fTrackIt*trackIt, iparent, kf, p, origin, polar,
+ PushTrack(fTrackIt*trackIt, iparent, kf, p, origin, polar,
tof, kPPrimary, nt, 1., ks);
KeepTrack(nt);
pParent[i] = nt;
// Get weight of current particle
TParticle *current = (TParticle*)
- (*gAlice->Particles())[gAlice->CurrentTrack()];
+ (*gAlice->Particles())[gAlice->GetCurrentTrackNumber()];
ifeed = Int_t(current->GetWeight()/100+0.5);
ipart = gMC->TrackPid();
// Put photon on the stack and label it as feedback (51, 52)
++sNfeed;
- gAlice->SetTrack(Int_t(1), gAlice->CurrentTrack(), Int_t(50000051),
+ gAlice->PushTrack(Int_t(1), gAlice->GetCurrentTrackNumber(), Int_t(50000051),
mom[0],mom[1],mom[2],mom[3],source[0],source[1],source[2],position[3],pol[0],pol[1],pol[2],
kPFeedBackPhoton, nt, 1.);
const Float_t kBig=1.e10;
TClonesArray &lhits = *fHits;
- TParticle *current = (TParticle*)(*gAlice->Particles())[gAlice->CurrentTrack()];
+ TParticle *current = (TParticle*)(*gAlice->Particles())[gAlice->GetCurrentTrackNumber()];
//if (current->Energy()>1)
//{
id=gMC->CurrentVolID(copy);
idvol = copy-1;
Float_t cherenkovLoss=0;
- //gAlice->KeepTrack(gAlice->CurrentTrack());
+ //gAlice->KeepTrack(gAlice->GetCurrentTrackNumber());
gMC->TrackPosition(position);
pos[0]=position(0);
ckovData[2] = pos[1]; // Y-position for hit
ckovData[3] = pos[2]; // Z-position for hit
ckovData[6] = 0; // dummy track length
- //ckovData[11] = gAlice->CurrentTrack();
+ //ckovData[11] = gAlice->GetCurrentTrackNumber();
- //printf("\n+++++++++++\nTrack: %d\n++++++++++++\n",gAlice->CurrentTrack());
+ //printf("\n+++++++++++\nTrack: %d\n++++++++++++\n",gAlice->GetCurrentTrackNumber());
//AliRICH *RICH = (AliRICH *) gAlice->GetDetector("RICH");
//printf("Second Mother:%d\n",current->GetSecondMother());
ckovData[10] = mother;
- ckovData[11] = gAlice->CurrentTrack();
+ ckovData[11] = gAlice->GetCurrentTrackNumber();
ckovData[12] = 1; //Media where photon was produced 1->Freon, 2->Quarz
//printf("Produced in FREO\n");
fCkovNumber++;
if (ranf[0] > t) {
gMC->StopTrack();
ckovData[13] = 5;
- AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
+ AddCerenkov(gAlice->GetCurrentTrackNumber(),vol,ckovData);
//printf("Added One (1)!\n");
//printf("Lost one in grid\n");
}
if (ranf[0] < t) {
gMC->StopTrack();
ckovData[13] = 6;
- AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
+ AddCerenkov(gAlice->GetCurrentTrackNumber(),vol,ckovData);
//printf("Added One (2)!\n");
//printf("Lost by Fresnel\n");
if (gMC->CurrentVolID(copy) == gMC->VolId("QUAR"))
ckovData[13]=2;
//gMC->StopTrack();
- //AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
+ //AddCerenkov(gAlice->GetCurrentTrackNumber(),vol,ckovData);
} //reflection question
// Absorption loss
ckovData[13]=16;
}
gMC->StopTrack();
- AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
+ AddCerenkov(gAlice->GetCurrentTrackNumber(),vol,ckovData);
//printf("Added One (3)!\n");
//printf("Added cerenkov %d\n",fCkovNumber);
} //absorption question
else if (procs[i] == kPStop) { //is it below energy treshold?
ckovData[13]=21;
gMC->StopTrack();
- AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
+ AddCerenkov(gAlice->GetCurrentTrackNumber(),vol,ckovData);
//printf("Added One (4)!\n");
} // energy treshold question
} //number of mechanisms cycle
}
//if (sector != -1)
//{
- AddHit(gAlice->CurrentTrack(),vol,ckovData);
- AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
+ AddHit(gAlice->GetCurrentTrackNumber(),vol,ckovData);
+ AddCerenkov(gAlice->GetCurrentTrackNumber(),vol,ckovData);
//printf("Added One (5)!\n");
//}
}
}
//if(sector !=-1)
- new(lhits[fNhits++]) AliRICHHit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+ new(lhits[fNhits++]) AliRICHHit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
eloss = 0;
//
// Check additional signal generation conditions
const Float_t kBig=1.e10;
TClonesArray &lhits = *fHits;
- TParticle *current = (TParticle*)(*gAlice->Particles())[gAlice->CurrentTrack()];
+ TParticle *current = (TParticle*)(*gAlice->Particles())[gAlice->GetCurrentTrackNumber()];
//if (current->Energy()>1)
//{
id=gMC->CurrentVolID(copy);
idvol = copy-1;
Float_t cherenkovLoss=0;
- //gAlice->KeepTrack(gAlice->CurrentTrack());
+ //gAlice->KeepTrack(gAlice->GetCurrentTrackNumber());
gMC->TrackPosition(position);
pos[0]=position(0);
ckovData[2] = pos[1]; // Y-position for hit
ckovData[3] = pos[2]; // Z-position for hit
ckovData[6] = 0; // dummy track length
- //ckovData[11] = gAlice->CurrentTrack();
+ //ckovData[11] = gAlice->GetCurrentTrackNumber();
- //printf("\n+++++++++++\nTrack: %d\n++++++++++++\n",gAlice->CurrentTrack());
+ //printf("\n+++++++++++\nTrack: %d\n++++++++++++\n",gAlice->GetCurrentTrackNumber());
//AliRICH *RICH = (AliRICH *) gAlice->GetDetector("RICH");
//printf("Second Mother:%d\n",current->GetSecondMother());
ckovData[10] = mother;
- ckovData[11] = gAlice->CurrentTrack();
+ ckovData[11] = gAlice->GetCurrentTrackNumber();
ckovData[12] = 1; //Media where photon was produced 1->Freon, 2->Quarz
//printf("Produced in FREO\n");
fCkovNumber++;
if (ranf[0] > t) {
gMC->StopTrack();
ckovData[13] = 5;
- AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
+ AddCerenkov(gAlice->GetCurrentTrackNumber(),vol,ckovData);
//printf("Added One (1)!\n");
//printf("Lost one in grid\n");
}
if (ranf[0] < t) {
gMC->StopTrack();
ckovData[13] = 6;
- AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
+ AddCerenkov(gAlice->GetCurrentTrackNumber(),vol,ckovData);
//printf("Added One (2)!\n");
//printf("Lost by Fresnel\n");
if (gMC->CurrentVolID(copy) == gMC->VolId("QUAR"))
ckovData[13]=2;
//gMC->StopTrack();
- //AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
+ //AddCerenkov(gAlice->GetCurrentTrackNumber(),vol,ckovData);
} //reflection question
// Absorption loss
ckovData[13]=16;
}
gMC->StopTrack();
- AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
+ AddCerenkov(gAlice->GetCurrentTrackNumber(),vol,ckovData);
//printf("Added One (3)!\n");
//printf("Added cerenkov %d\n",fCkovNumber);
} //absorption question
else if (procs[i] == kPStop) { //is it below energy treshold?
ckovData[13]=21;
gMC->StopTrack();
- AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
+ AddCerenkov(gAlice->GetCurrentTrackNumber(),vol,ckovData);
//printf("Added One (4)!\n");
} // energy treshold question
} //number of mechanisms cycle
}
//if (sector != -1)
//{
- AddHit(gAlice->CurrentTrack(),vol,ckovData);
- AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
+ AddHit(gAlice->GetCurrentTrackNumber(),vol,ckovData);
+ AddCerenkov(gAlice->GetCurrentTrackNumber(),vol,ckovData);
//printf("Added One (5)!\n");
//}
}
}
//if(sector !=-1)
- new(lhits[fNhits++]) AliRICHHit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+ new(lhits[fNhits++]) AliRICHHit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
eloss = 0;
//
// Check additional signal generation conditions
Float_t de=gMC->Edep();
edep=edep+de;
hits[3]=edep*1e3;
- new(lhits[fNhits++]) AliSTARThit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+ new(lhits[fNhits++]) AliSTARThit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
}
}
//---------------------------------------------------------------------
hitPhoton[4] = 1e9 * gMC->TrackTime();
hitPhoton[5] = 1e9 * gMC->Etot();
- AddHitPhoton (gAlice->CurrentTrack(), vol, hitPhoton);
+ AddHitPhoton (gAlice->GetCurrentTrackNumber(), vol, hitPhoton);
}
gMC->StopTrack();
}
// printf(" HITS on START Exit %f\n",hits[i]); }
//for (i=0; i<=1; i++) { printf("START vol %d\n",vol[i]);}
- new(lhits[fNhits++]) AliSTARThit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+ new(lhits[fNhits++]) AliSTARThit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
}
}
}
//_______________________________________________________________________
-void AliGenerator::SetTrack(Int_t done, Int_t parent, Int_t pdg,
+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)
//
if (fStack)
- fStack->SetTrack(done, parent, pdg, pmom, vpos, polar, tof,
+ fStack->PushTrack(done, parent, pdg, pmom, vpos, polar, tof,
mech, ntr, weight, is);
else
- gAlice->SetTrack(done, parent, pdg, pmom, vpos, polar, tof,
+ gAlice->PushTrack(done, parent, pdg, pmom, vpos, polar, tof,
mech, ntr, weight, is);
}
//_______________________________________________________________________
-void AliGenerator::SetTrack(Int_t done, Int_t parent, Int_t pdg,
+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,
//
if (fStack)
- fStack->SetTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
+ fStack->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
polx, poly, polz, mech, ntr, weight, is);
else
- gAlice->SetTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
+ gAlice->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
polx, poly, polz, mech, ntr, weight, is);
}
virtual AliCollisionGeometry* CollisionGeometry() {return fCollisionGeometry;}
virtual void SetCollisionGeometry(AliCollisionGeometry* geom) {fCollisionGeometry = geom;}
protected:
- virtual void SetTrack(Int_t done, Int_t parent, Int_t pdg,
+ 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 SetTrack(Int_t done, Int_t parent, Int_t pdg,
+ 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,
fStepsForward = 0;
fStepsBackward = 0;
fErrorCondition = 0;
- if (gAlice->CurrentTrack() == 0) fStepBack = 0;
+ if (gAlice->GetCurrentTrackNumber() == 0) fStepBack = 0;
}
}
orig[1] = vect[1];
orig[2] = vect[2];
- gAlice->SetTrack(1, gAlice->CurrentTrack(),
+ gAlice->PushTrack(1, gAlice->GetCurrentTrackNumber(),
0, pmom, orig, polar, 0., kPNoProcess, ntr);
} // debug
Float_t polar[3]={0.,0.,0.};
Int_t ntr;
- gAlice->SetTrack(1, -1, kMpart, pmom, orig, polar, 0, kPPrimary, ntr);
+ gAlice->PushTrack(1, -1, kMpart, pmom, orig, polar, 0, kPPrimary, ntr);
}
Float_t polar[3]={0.,0.,0.};
Int_t ntr;
- gAlice->SetTrack(1, -1, kMpart, pmom, orig, polar, 0, kPPrimary, ntr);
+ gAlice->PushTrack(1, -1, kMpart, pmom, orig, polar, 0, kPPrimary, ntr);
}
Float_t polar[3]={0.,0.,0.};
Int_t ntr;
- gAlice->SetTrack(1, -1, kMpart, pmom, orig, polar, 0, kPPrimary, ntr);
+ gAlice->PushTrack(1, -1, kMpart, pmom, orig, polar, 0, kPPrimary, ntr);
}
Float_t polar[3]={0.,0.,0.};
Int_t ntr;
- gAlice->SetTrack(1, -1, kMpart, pmom, orig, polar, 0, kPPrimary, ntr);
+ gAlice->PushTrack(1, -1, kMpart, pmom, orig, polar, 0, kPPrimary, ntr);
}
}
//_______________________________________________________________________
-void AliRun::SetTrack(Int_t done, Int_t parent, Int_t pdg, Float_t *pmom,
+void AliRun::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)
{
// Delegate to stack
//
- fRunLoader->Stack()->SetTrack(done, parent, pdg, pmom, vpos, polar, tof,
+ fRunLoader->Stack()->PushTrack(done, parent, pdg, pmom, vpos, polar, tof,
mech, ntr, weight, is);
}
//_______________________________________________________________________
-void AliRun::SetTrack(Int_t done, Int_t parent, Int_t pdg,
+void AliRun::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,
{
// Delegate to stack
//
- fRunLoader->Stack()->SetTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
+ fRunLoader->Stack()->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
polx, poly, polz, mech, ntr, weight, is);
}
//_______________________________________________________________________
-Int_t AliRun::CurrentTrack() const {
+Int_t AliRun::GetCurrentTrackNumber() const {
//
// Returns current track
//
- return fRunLoader->Stack()->CurrentTrack();
+ return fRunLoader->Stack()->GetCurrentTrackNumber();
}
//_______________________________________________________________________
virtual void CleanDetectors();
TObjArray *Detectors() const {return fModules;}
TObjArray *Modules() const {return fModules;}
- Int_t CurrentTrack() const;
+ Int_t GetCurrentTrackNumber() const;
AliDisplay *Display() const { return fDisplay;}
virtual Int_t DistancetoPrimitive(Int_t px, Int_t py) const;
virtual void DumpPart (Int_t i) const;
virtual void SetDisplay(AliDisplay *display) {fDisplay = display;}
virtual void SetField(Int_t type=2, Int_t version=1, Float_t scale=1, Float_t maxField=10, char*filename="$(ALICE_ROOT)/data/field01.dat");
virtual void SetField(AliMagF* magField);
- virtual void SetTrack(Int_t done, Int_t parent, Int_t pdg,
+ 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 SetTrack(Int_t done, Int_t parent, Int_t pdg,
+ 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,
//
//_____________________________________________________________________________
-void AliStack::SetTrack(Int_t done, Int_t parent, Int_t pdg, Float_t *pmom,
+void AliStack::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)
{
// mass,e,fNtrack,pdg,parent,done,vpos[0],vpos[1],vpos[2],pmom[0],pmom[1],pmom[2],kS);
- SetTrack(done, parent, pdg, pmom[0], pmom[1], pmom[2], e,
+ PushTrack(done, parent, pdg, pmom[0], pmom[1], pmom[2], e,
vpos[0], vpos[1], vpos[2], tof, polar[0], polar[1], polar[2],
mech, ntr, weight, is);
} else {
- Warning("SetTrack", "Particle type %d not defined in PDG Database !\n", pdg);
- Warning("SetTrack", "Particle skipped !\n");
+ Warning("PushTrack", "Particle type %d not defined in PDG Database !\n", pdg);
+ Warning("PushTrack", "Particle skipped !\n");
}
}
//_____________________________________________________________________________
-void AliStack::SetTrack(Int_t done, Int_t parent, Int_t pdg,
+void AliStack::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,
if(particle->GetFirstDaughter()<0) particle->SetFirstDaughter(fNtrack);
}
else {
- printf("Error in AliStack::SetTrack: Parent %d does not exist\n",parent);
+ printf("Error in AliStack::PushTrack: Parent %d does not exist\n",parent);
}
}
else {
}
//_____________________________________________________________________________
-TParticle* AliStack::GetNextTrack(Int_t& itrack)
+TParticle* AliStack::PopNextTrack(Int_t& itrack)
{
//
// Returns next track from stack of particles
}
//_____________________________________________________________________________
-TParticle* AliStack::GetPrimaryForTracking(Int_t i)
+TParticle* AliStack::PopPrimaryForTracking(Int_t i)
{
//
// Returns i-th primary particle if it is flagged to be tracked,
}
//_____________________________________________________________________________
-Int_t AliStack::CurrentTrackParent() const
+Int_t AliStack::GetCurrentParentTrackNumber() const
{
//
// Return number of the parent of the current track
if (current)
return current->GetFirstMother();
else {
- Warning("CurrentTrackParent", "Current track not found in the stack");
+ Warning("GetCurrentParentTrackNumber", "Current track not found in the stack");
return -1;
}
}
// methods
- virtual void SetTrack(Int_t done, Int_t parent, Int_t pdg,
+ 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, Int_t is);
- virtual void SetTrack(Int_t done, Int_t parent, Int_t pdg,
+ 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, Double_t weight,
Int_t is);
- virtual TParticle* GetNextTrack(Int_t& track);
- virtual TParticle* GetCurrentTrack() {return fCurrentTrack;}
- virtual TParticle* GetPrimaryForTracking(Int_t i);
+ virtual TParticle* PopNextTrack(Int_t& track);
+ virtual TParticle* GetCurrentTrack() const {return fCurrentTrack;}
+ virtual TParticle* PopPrimaryForTracking(Int_t i);
void ConnectTree();
void BeginEvent();
// get methods
virtual Int_t GetNtrack() const;
Int_t GetNprimary() const;
- virtual Int_t CurrentTrack() const;
- virtual Int_t CurrentTrackParent() const;
+ virtual Int_t GetCurrentTrackNumber() const;
+ virtual Int_t GetCurrentParentTrackNumber() const;
TObjArray* Particles() const;
TParticle* Particle(Int_t id);
Int_t GetPrimary(Int_t id);
inline Int_t AliStack::GetNprimary() const
{ return fNprimary; }
-inline Int_t AliStack::CurrentTrack() const
+inline Int_t AliStack::GetCurrentTrackNumber() const
{ return fCurrent; }
inline TObjArray* AliStack::Particles() const
//
// Add the reference track
//
- AddTrackReference(gAlice->CurrentTrack());
+ AddTrackReference(gAlice->GetCurrentTrackNumber());
}
kf==5301 || kf==5303 || kf==5401 || kf==5403 || kf==5503)
tFlag=kFALSE;
*/
- SetTrack(tFlag,imo,kf,p,origin,polar,tof,kPNoProcess,nt, 1., ks);
+ PushTrack(tFlag,imo,kf,p,origin,polar,tof,kPNoProcess,nt, 1., ks);
KeepTrack(nt);
newPos[i] = nt;
} // if selected
id = 11;
if (fDebug == 2)
printf("id=%+3d, p = (%+11.4e,%+11.4e,%+11.4e) GeV\n",id,p[0],p[1],p[2]);
- SetTrack(fTrackIt,-1, id,p,origin,polar,0,kPPrimary,nt,weight);
+ PushTrack(fTrackIt,-1, id,p,origin,polar,0,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]);
- SetTrack(fTrackIt,-1, id,p,origin,polar,0,kPPrimary,nt,weight);
+ PushTrack(fTrackIt,-1, id,p,origin,polar,0,kPPrimary,nt,weight);
fEvent++;
if (fEvent%1000 == 0) {
if (EVTFLG.lpairp == 1) mech = kPPair;
else if (EVTFLG.lphoel == 1) mech = kPPhotoelectric;
else mech = kPAnnihilation;
- cppstack->SetTrack(done, parent, pdg,
+ cppstack->PushTrack(done, parent, pdg,
px, py, pz, e, vx, vy, vz, tof,
polx, poly, polz, mech, ntr, weight, is);
cout << endl << " !!! stupre (PAIR, ..) : ntr=" << ntr << "pdg " << pdg << " parent=" << parent << endl;
if (EMFSTK.ichemf[kp] != 0) {
mech = kPCompton;
- cppstack->SetTrack(done, parent, pdg,
+ cppstack->PushTrack(done, parent, pdg,
px, py, pz, e, vx, vy, vz, tof,
polx, poly, polz, mech, ntr, weight, is);
cout << endl << " !!! stupre (COMPTON) : ntr=" << ntr << "pdg " << pdg << " parent=" << parent << endl;
else if ((EVTFLG.lbrmsp == 1)) {
if (EMFSTK.ichemf[kp] == 0) {
mech = kPBrem;
- cppstack->SetTrack(done, parent, pdg,
+ cppstack->PushTrack(done, parent, pdg,
px, py, pz, e, vx, vy, vz, tof,
polx, poly, polz, mech, ntr, weight, is);
cout << endl << " !!! stupre (BREMS) : ntr=" << ntr << "pdg " << pdg << " parent=" << parent << endl;
if (lbhabh == 1) {
if (EMFSTK.ichemf[kp] == -1) {
mech = kPDeltaRay;
- cppstack->SetTrack(done, parent, pdg,
+ cppstack->PushTrack(done, parent, pdg,
px, py, pz, e, vx, vy, vz, tof,
polx, poly, polz, mech, ntr, weight, is);
EMFSTK.iespak[kp][mkbmx2-1] = ntr;
//* lower energy, which has been put higher in the stack
else if (kp == EMFSTK.npemf-1) {
mech = kPDeltaRay;
- cppstack->SetTrack(done, parent, pdg,
+ cppstack->PushTrack(done, parent, pdg,
px, py, pz, e, vx, vy, vz, tof,
polx, poly, polz, mech, ntr, weight, is);
cout << endl << " !!! stupre (Moller) : ntr=" << ntr << "pdg " << pdg << " parent=" << parent << endl;
// was numsec -1
// clarify with Alberto
if (numsec > npprmr) {
-// Now call the SetTrack(...)
+// Now call the PushTrack(...)
Int_t done = 1;
Int_t parent = TRACKR.ispusr[mkbmx2-1];
Int_t ntr;
//
// Save particle in VMC stack
- cppstack->SetTrack(done, parent, pdg,
+ cppstack->PushTrack(done, parent, pdg,
px, py, pz, e,
vx, vy, vz, tof,
polx, poly, polz,
Float_t tof = kconv*iparticle->T();
Int_t iparent = (imo > -1) ? newPos[imo] : -1;
Int_t trackIt = (ks == 1) && fTrackIt;
- gAlice->SetTrack(trackIt, iparent, kf,
+ gAlice->PushTrack(trackIt, iparent, kf,
p[0], p[1], p[2], p[3],
origin[0], origin[1], origin[2],
tof,
imo = (mother->GetPdgCode() != 92) ? imo = newPos[imo] : -1;
} // if has mother
Bool_t tFlag = (fTrackIt && !hasDaughter);
- SetTrack(tFlag,imo,kf,p,origin,polar,
+ PushTrack(tFlag,imo,kf,p,origin,polar,
tof,kPNoProcess,nt, 1., ks);
KeepTrack(nt);
newPos[i] = nt;
p[1] = particle->Py();
p[2] = particle->Pz();
- SetTrack(fTrackIt, parent, pdg, p, orgin, polar, time, kPPrimary, id);
+ PushTrack(fTrackIt, parent, pdg, p, orgin, polar, time, kPPrimary, id);
}
vol[3]= padx;
vol[4]= padz;
- AddHit(gAlice->CurrentTrack(),vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(),vol, hits);
}
}
vol[3]= padx;
vol[4]= padz;
- AddHit(gAlice->CurrentTrack(),vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(),vol, hits);
}
}
vol[3]= padx;
vol[4]= padz;
- AddHit(gAlice->CurrentTrack(),vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(),vol, hits);
}
}
vol[3]= padx;
vol[4]= padz;
- AddHit(gAlice->CurrentTrack(),vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(),vol, hits);
}
}
vol[3]= padx;
vol[4]= padz;
- AddHit(gAlice->CurrentTrack(),vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(),vol, hits);
}
}
vol[3]= padx;
vol[4]= padz;
- AddHit(gAlice->CurrentTrack(),vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(),vol, hits);
}
}
vol[3]= padx;
vol[4]= padz;
- AddT0Hit(gAlice->CurrentTrack(),vol, hits);
+ AddT0Hit(gAlice->GetCurrentTrackNumber(),vol, hits);
}
}
hits[1]=p[1];
hits[2]=p[2];
hits[3]=0.; // this hit has no energy loss
- // new(lhits[fNhits++]) AliTPChit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+ // new(lhits[fNhits++]) AliTPChit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
- AddHit(gAlice->CurrentTrack(), vol,hits); // M.I.
+ AddHit(gAlice->GetCurrentTrackNumber(), vol,hits); // M.I.
gMC->TrackPosition(p);
hits[0]=p[0];
hits[1]=p[1];
hits[2]=p[2];
hits[3]=0.; // this hit has no energy loss
- // new(lhits[fNhits++]) AliTPChit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+ // new(lhits[fNhits++]) AliTPChit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
- AddHit(gAlice->CurrentTrack(), vol,hits); // M.I.
+ AddHit(gAlice->GetCurrentTrackNumber(), vol,hits); // M.I.
}
gMC->TrackPosition(p);
for(i=0;i<3;++i) hits[i]=p[i];
hits[3]=1; //I'd like to have something positive here (I.Belikov)
- // new(lhits[fNhits++]) AliTPChit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+ // new(lhits[fNhits++]) AliTPChit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
- AddHit(gAlice->CurrentTrack(), vol,hits); // M.I.
+ AddHit(gAlice->GetCurrentTrackNumber(), vol,hits); // M.I.
}
if ( (gMC->IsTrackEntering() || gMC->IsTrackExiting()) &&
((id == fIdLSec) || (id == fIdUSec)) ) {
- AddTrackReference(gAlice->CurrentTrack());
+ AddTrackReference(gAlice->GetCurrentTrackNumber());
}
if(id == fIdLSec){
hits[1]=p[1];
hits[2]=p[2];
hits[3]=0.; // this hit has no energy loss
- // new(lhits[fNhits++]) AliTPChit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+ // new(lhits[fNhits++]) AliTPChit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
- AddHit(gAlice->CurrentTrack(), vol,hits); //MI change
+ AddHit(gAlice->GetCurrentTrackNumber(), vol,hits); //MI change
}
hits[1]=p[1];
hits[2]=p[2];
hits[3]=0.; // this hit has no energy loss
- // new(lhits[fNhits++]) AliTPChit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+ // new(lhits[fNhits++]) AliTPChit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
- AddHit(gAlice->CurrentTrack(), vol,hits); //MI change
+ AddHit(gAlice->GetCurrentTrackNumber(), vol,hits); //MI change
}
else return;
// Add this hit
- // new(lhits[fNhits++]) AliTPChit(fIshunt,gAlice->CurrentTrack(),vol,hits);
+ // new(lhits[fNhits++]) AliTPChit(fIshunt,gAlice->GetCurrentTrackNumber(),vol,hits);
if (fHitType&&2){
gMC->TrackMomentum(p);
Float_t momentum = TMath::Sqrt(p[0]*p[0]+p[1]*p[1]);
Float_t precision = (momentum>0.1) ? 0.002 :0.01;
fTrackHits->SetHitPrecision(precision);
}
- AddHit(gAlice->CurrentTrack(), vol,hits); //MI change
+ AddHit(gAlice->GetCurrentTrackNumber(), vol,hits); //MI change
}
// Add this hit
- AddHit(gAlice->CurrentTrack(), vol,hits); //MI change
+ AddHit(gAlice->GetCurrentTrackNumber(), vol,hits); //MI change
}
tof = kconv*iparticle->T();
if (ks == 1) trackIt = 1;
else trackIt = 0;
- SetTrack(fTrackIt*trackIt,iparent,kf,p,origin,polar,tof,kPPrimary,nt,weight,ks);
+ PushTrack(fTrackIt*trackIt,iparent,kf,p,origin,polar,tof,kPPrimary,nt,weight,ks);
KeepTrack(nt);
if (fDebug == 2)
Float_t vtx[3] = { 0.0 };
Float_t pol[3] = { 0.0 };
Int_t ntr = 0;
- gAlice->SetTrack(0,-1,fPdg,mom,vtx,pol,0.0,kPPrimary,ntr);
+ gAlice->PushTrack(0,-1,fPdg,mom,vtx,pol,0.0,kPPrimary,ntr);
}
//_____________________________________________________________________________
AliTRDsimpleMC::AliTRDsimpleMC(const char *name, const char *title)
- :TVirtualMC(name,title)
+ :TVirtualMC(name,title,kFALSE)
{
//
// AliTRDsimpleMC default constructor
pla = ((Int_t) idChamber % kNplan);
det = fGeometry->GetDetector(pla,cha,sec);
- AddHit(gAlice->CurrentTrack(),det,hits,0,kTRUE);
+ AddHit(gAlice->GetCurrentTrackNumber(),det,hits,0,kTRUE);
}
// Add the hit to the array. TR photon hits are marked
// by negative charge
- AddHit(gAlice->CurrentTrack(),det,posHit,-q,kTRUE);
+ AddHit(gAlice->GetCurrentTrackNumber(),det,posHit,-q,kTRUE);
}
// momentum components of the particle
if (gMC->IsTrackEntering() || gMC->IsTrackExiting()) {
gMC->TrackMomentum(mom);
- AddTrackReference(gAlice->CurrentTrack());
+ AddTrackReference(gAlice->GetCurrentTrackNumber());
}
// Create the hits from TR photons
// Create a new dEdx hit
if (drRegion) {
- AddHit(gAlice->CurrentTrack(),det,hits,qTot,kTRUE);
+ AddHit(gAlice->GetCurrentTrackNumber(),det,hits,qTot,kTRUE);
}
else {
- AddHit(gAlice->CurrentTrack(),det,hits,qTot,kFALSE);
+ AddHit(gAlice->GetCurrentTrackNumber(),det,hits,qTot,kFALSE);
}
// Calculate the maximum step size for the next tracking step
hits[13] = mom[2];
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
}
hits[12] = mom[1];
hits[13] = mom[2];
- TParticle *par = gAlice->Particle(gAlice->CurrentTrack());
+ TParticle *par = gAlice->Particle(gAlice->GetCurrentTrackNumber());
hits[14] = par->Vx();
hits[15] = par->Vy();
hits[16] = par->Vz();
hits[17] = eloss;
hits[18] = tlength;
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
tlength = 0.0;
eloss = 0.0;
}
Float_t polar[3] = {0,0,0};
- gAlice->SetTrack(fTrackIt,-1,fIpart,fPTrack,fOrigin.GetArray(),polar,0,
+ gAlice->PushTrack(fTrackIt,-1,fIpart,fPTrack,fOrigin.GetArray(),polar,0,
kPPrimary,nt);
if(fDebugOpt == 1){
printf("\n\n Track momentum:\n");
// Int_t PcID = gMC->TrackPid();
// printf("Pc ID -> %d\n",PcID);
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
if(fNoShower==1){
// fpDetected += 1;
hits[9] = ekin;
hits[7] = 0.;
hits[8] = 0.;
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
}
else{
hits[9] = destep;
hits[7] = 0.;
hits[8] = 0.;
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
}
// printf(" Dep. E = %f \n",hits[9]);
}
hits[7] = nphe; //fLightPMQ
hits[8] = 0;
hits[9] = 0;
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
}
else{
hits[7] = 0;
hits[8] = nphe; //fLightPMC
hits[9] = 0;
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
}
}
else if((vol[0]==2)) { // (2) ZP fibres
hits[7] = nphe; //fLightPMQ
hits[8] = 0;
hits[9] = 0;
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
}
else{
hits[7] = 0;
hits[8] = nphe; //fLightPMC
hits[9] = 0;
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
}
}
else if((vol[0]==3)) { // (3) ZEM fibres
hits[7] = 0;
hits[8] = nphe; //fLightPMC
hits[9] = 0;
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
}
}
}
// Int_t PcID = gMC->TrackPid();
// printf("Pc ID -> %d\n",PcID);
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
if(fNoShower==1){
fpDetected += 1;
hits[9] = ekin;
hits[7] = 0.;
hits[8] = 0.;
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
}
else{
hits[9] = destep;
hits[7] = 0.;
hits[8] = 0.;
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
}
// printf(" Dep. E = %f \n",hits[9]);
}
hits[7] = nphe; //fLightPMQ
hits[8] = 0;
hits[9] = 0;
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
}
else{
hits[7] = 0;
hits[8] = nphe; //fLightPMC
hits[9] = 0;
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
}
}
else if((vol[0]==2)) { // (2) ZP fibres
hits[7] = nphe; //fLightPMQ
hits[8] = 0;
hits[9] = 0;
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
}
else{
hits[7] = 0;
hits[8] = nphe; //fLightPMC
hits[9] = 0;
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
}
}
else if((vol[0]==3)) { // (3) ZEM fibres
hits[7] = 0;
hits[8] = nphe; //fLightPMC (ZEM1)
hits[9] = 0;
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
}
else{
hits[7] = nphe; //fLightPMQ (ZEM2)
hits[8] = 0;
hits[9] = 0;
- AddHit(gAlice->CurrentTrack(), vol, hits);
+ AddHit(gAlice->GetCurrentTrackNumber(), vol, hits);
}
}
}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff