///////////////////////////////////////////////////////////////////////////////
+#include <TClonesArray.h>
#include <TObjArray.h>
+#include <TPDGCode.h>
#include <TParticle.h>
#include <TParticlePDG.h>
#include <TTree.h>
fParticleMap(0),
fParticleFileMap(0),
fParticleBuffer(0),
+ fCurrentTrack(0),
fTreeK(0),
fNtrack(0),
fNprimary(0),
fParticleMap(new TObjArray(size)),
fParticleFileMap(0),
fParticleBuffer(0),
+ fCurrentTrack(0),
fTreeK(0),
fNtrack(0),
fNprimary(0),
//_______________________________________________________________________
AliStack::AliStack(const AliStack& st):
- TVirtualMCStack(st),
- fParticles(0),
- fParticleMap(0),
- fParticleFileMap(0),
- fParticleBuffer(0),
- fTreeK(0),
- fNtrack(0),
- fNprimary(0),
- fCurrent(-1),
- fCurrentPrimary(-1),
- fHgwmk(0),
- fLoadPoint(0)
+ TVirtualMCStack(st),
+ fParticles(new TClonesArray("TParticle",1000)),
+ fParticleMap(new TObjArray(*st.Particles())),
+ fParticleFileMap(st.fParticleFileMap),
+ fParticleBuffer(0),
+ fCurrentTrack(0),
+ fTreeK((TTree*)(st.fTreeK->Clone())),
+ fNtrack(st.GetNtrack()),
+ fNprimary(st.GetNprimary()),
+ fCurrent(-1),
+ fCurrentPrimary(-1),
+ fHgwmk(0),
+ fLoadPoint(0),
+ fEventFolderName(0)
{
- //
- // Copy constructor
- //
- st.Copy(*this);
+ // Copy constructor
+ ConnectTree();
}
+
//_______________________________________________________________________
void AliStack::Copy(TObject&) const
{
if(fHgwmk+1 == fNtrack) return;
// First pass, invalid Daughter information
-
- for(i=0; i<fNtrack; i++) {
+ for(i=0; i<fNtrack; i++) {
// Preset map, to be removed later
if(i<=fHgwmk) map[i]=i ;
else {
}
}
}
+
// Now loop on all registered hit lists
TList* hitLists = gAlice->GetMCApp()->GetHitLists();
while((hitList = dynamic_cast<TCollection*>(next()))) {
TIter nexthit(hitList);
AliHit *hit;
+
while((hit = dynamic_cast<AliHit*>(nexthit()))) {
hit->SetTrack(map[hit->GetTrack()]);
}
//
// Howmany secondaries have been produced ?
Int_t nNew = fNtrack - fHgwmk - 1;
-
+
if (nNew > 0) {
Int_t i, j;
TObjArray &particles = *fParticleMap;
for (i = 0; i < nNew; i++) {
if (particles.At(fHgwmk + 1 + i)) {
-// tmp[i] = (TParticle*) (particles.At(fHgwmk + 1 + i))->Clone();
tmp[i] = (TParticle*) (particles.At(fHgwmk + 1 + i));
-
-// if (((TParticle*) (particles.At(fHgwmk + 1 + i)))->TestBit(kKeepBit))
-// tmp[i]->SetBit(kKeepBit);
-// if (((TParticle*) (particles.At(fHgwmk + 1 + i)))->TestBit(kDoneBit))
-// tmp[i]->SetBit(kDoneBit);
} else {
tmp[i] = 0x0;
}
// The outer loop is over parents, the inner over children.
// -1 refers to the primary particle
//
- for (i = -1; i < nNew - 1; i++) {
+ for (i = -1; i < nNew-1; i++) {
Int_t ipa;
TParticle* parP;
if (i == -1) {
parP = tmp[i];
}
// Reset daughter information
+
+ Int_t idaumin = parP->GetFirstDaughter() - fHgwmk - 1;
+ Int_t idaumax = parP->GetLastDaughter() - fHgwmk - 1;
parP->SetFirstDaughter(-1);
parP->SetLastDaughter(-1);
- for (j = i + 1; j < nNew; j++) {
+ for (j = idaumin; j <= idaumax; j++) {
// Skip deleted particles
if (!tmp[j]) continue;
// Skip particles already handled
//Sets event folder name
fEventFolderName = foldname;
}
+
+Bool_t AliStack::IsStable(Int_t pdg) const
+{
+//
+// Decide whether particle (pdg) is stable
+//
+
+ const Int_t kNstable = 14;
+ Int_t i;
+
+ Int_t pdgStable[kNstable] = {
+ kGamma, // Photon
+ kElectron, // Electron
+ kMuonPlus, // Muon
+ kPiPlus, // Pion
+ kKPlus, // Kaon
+ kProton, // Proton
+ kNeutron, // Neutron
+ kLambda0, // Lambda_0
+ kSigmaMinus, // Sigma Minus
+ kSigma0, // Sigma_0
+ kSigmaPlus, // Sigma Plus
+ 3312, // Xsi Minus
+ 3322, // Xsi
+ 3334, // Omega
+ };
+
+ Bool_t isStable = kFALSE;
+ for (i = 0; i < kNstable; i++) {
+ if (pdg == TMath::Abs(pdgStable[i])) {
+ isStable = kTRUE;
+ break;
+ }
+ }
+
+ return isStable;
+}
+
+Bool_t AliStack::IsPhysicalPrimary(Int_t index)
+{
+ //
+ // Test if a particle is a physical primary according to the following definition:
+ // Particles produced in the collision including products of strong and
+ // electromagnetic decay and excluding feed-down from weak decays of strange
+ // particles.
+ //
+ TParticle* p = Particle(index);
+ Int_t ist = p->GetStatusCode();
+
+ //
+ // Initial state particle
+ if (ist > 20) return kFALSE;
+
+ Int_t pdg = TMath::Abs(p->GetPdgCode());
+
+ if (!IsStable(pdg)) return kFALSE;
+
+ if (index < GetNprimary()) {
+//
+// Particle produced by generator
+ return kTRUE;
+ } else {
+//
+// Particle produced during transport
+//
+// Check if this is a heavy flavor decay product
+ Int_t imo = p->GetFirstMother();
+ TParticle* pm = Particle(imo);
+ Int_t mpdg = TMath::Abs(pm->GetPdgCode());
+ Int_t mfl = Int_t (mpdg / TMath::Power(10, Int_t(TMath::Log10(mpdg))));
+ //
+ // Light hadron
+ if (mfl < 4) return kFALSE;
+
+ //
+ // Heavy flavor hadron produced by generator
+ if (imo < GetNprimary()) {
+ return kTRUE;
+ }
+
+ // To be sure that heavy flavor has not been produced in a secondary interaction
+ // Loop back to the generated mother
+ while (imo >= GetNprimary()) {
+ imo = p->GetFirstMother();
+ pm = Particle(imo);
+ }
+ mpdg = TMath::Abs(pm->GetPdgCode());
+ mfl = Int_t (mpdg / TMath::Power(10, Int_t(TMath::Log10(mpdg))));
+
+ if (mfl < 4) {
+ return kFALSE;
+ } else {
+ return kTRUE;
+ }
+ } // produced by generator ?
+}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff