ShipStack Class Reference

#include <ShipStack.h>

Inheritance diagram for ShipStack:

Collaboration diagram for ShipStack:

Public Member Functions
	ShipStack (Int_t size=100)
virtual	~ShipStack ()
virtual void	PushTrack (Int_t toBeDone, Int_t parentID, Int_t pdgCode, Double_t px, Double_t py, Double_t pz, Double_t e, Double_t vx, Double_t vy, Double_t vz, Double_t time, Double_t polx, Double_t poly, Double_t polz, TMCProcess proc, Int_t &ntr, Double_t weight, Int_t is)
virtual void	PushTrack (Int_t toBeDone, Int_t parentID, Int_t pdgCode, Double_t px, Double_t py, Double_t pz, Double_t e, Double_t vx, Double_t vy, Double_t vz, Double_t time, Double_t polx, Double_t poly, Double_t polz, TMCProcess proc, Int_t &ntr, Double_t weight, Int_t is, Int_t secondParentId)
virtual TParticle *	PopNextTrack (Int_t &iTrack)
virtual TParticle *	PopPrimaryForTracking (Int_t iPrim)
virtual void	SetCurrentTrack (Int_t iTrack)
virtual Int_t	GetNtrack () const
virtual Int_t	GetNprimary () const
virtual TParticle *	GetCurrentTrack () const
virtual Int_t	GetCurrentTrackNumber () const
virtual Int_t	GetCurrentParentTrackNumber () const
virtual void	AddParticle (TParticle *part)
virtual void	FillTrackArray ()
virtual void	UpdateTrackIndex (TRefArray *detArray=0)
virtual void	Reset ()
virtual void	Register ()
virtual void	Print (Int_t iVerbose=0) const
void	StoreSecondaries (Bool_t choice=kTRUE)
void	SetMinPoints (Int_t min)
void	SetEnergyCut (Double_t eMin)
void	StoreMothers (Bool_t choice=kTRUE)
void	AddPoint (DetectorId iDet)
void	AddPoint (DetectorId iDet, Int_t iTrack)
TParticle *	GetParticle (Int_t trackId) const
TClonesArray *	GetListOfParticles ()

Private Member Functions
void	SelectTracks ()
	ShipStack (const ShipStack &)
ShipStack &	operator= (const ShipStack &)

Private Attributes
std::stack< TParticle * >	fStack
TClonesArray *	fParticles
TClonesArray *	fTracks
std::map< Int_t, Bool_t >	fStoreMap
std::map< Int_t, Bool_t >::iterator	fStoreIter
std::map< Int_t, Int_t >	fIndexMap
std::map< Int_t, Int_t >::iterator	fIndexIter
std::map< std::pair< Int_t, Int_t >, Int_t >	fPointsMap
Int_t	fCurrentTrack
Int_t	fNPrimaries
	Index of current track.
Int_t	fNParticles
	Number of primary particles.
Int_t	fNTracks
	Number of entries in fParticles.
Int_t	fIndex
	Number of entries in fTracks.
Bool_t	fStoreSecondaries
	Used for merging.
Int_t	fMinPoints
Double32_t	fEnergyCut
Bool_t	fStoreMothers

Detailed Description

Definition at line 46 of file ShipStack.h.

Constructor & Destructor Documentation

ShipStack() [1/2]

ShipStack::ShipStack

(

Int_t

size = 100

)

Default constructor param size Estimated track number

Definition at line 29 of file ShipStack.cxx.

  : FairGenericStack(),
    fStack(),
    fParticles(new TClonesArray("TParticle", size)),
    fTracks(new TClonesArray("ShipMCTrack", size)),
    fStoreMap(),
    fStoreIter(),
    fIndexMap(),
    fIndexIter(),
    fPointsMap(),
    fCurrentTrack(-1),
    fNPrimaries(0),
    fNParticles(0),
    fNTracks(0),
    fIndex(0),
    fStoreSecondaries(kTRUE),
    fMinPoints(1),
    fEnergyCut(0.),
    fStoreMothers(kTRUE)
{
}

~ShipStack()

ShipStack::~ShipStack ( )

virtual

Destructor

Definition at line 56 of file ShipStack.cxx.

{
  if (fParticles) {
    fParticles->Delete();
    delete fParticles;
  }
  if (fTracks) {
    fTracks->Delete();
    delete fTracks;
  }
}

ShipStack() [2/2]

ShipStack::ShipStack ( const ShipStack &  )

private

Member Function Documentation

AddParticle()

void ShipStack::AddParticle ( TParticle *  part )

virtual

Add a TParticle to the fParticles array

Definition at line 211 of file ShipStack.cxx.

{
  TClonesArray& array = *fParticles;
  TParticle* newPart = new(array[fIndex]) TParticle(*oldPart);
  newPart->SetWeight(oldPart->GetWeight());
  newPart->SetUniqueID(oldPart->GetUniqueID());
  fIndex++;
}

AddPoint() [1/2]

void ShipStack::AddPoint

(

DetectorId

iDet

)

Increment number of points for the current track in a given detector

Parameters

iDet	Detector unique identifier

Definition at line 373 of file ShipStack.cxx.

{
  Int_t iDet = detId;
// cout << "Add point for Detektor" << iDet << endl;
  pair<Int_t, Int_t> a(fCurrentTrack, iDet);
  if ( fPointsMap.find(a) == fPointsMap.end() ) { fPointsMap[a] = 1; }
  else { fPointsMap[a]++; }
}

AddPoint() [2/2]

void ShipStack::AddPoint	(	DetectorId	iDet,
		Int_t	iTrack
	)

Increment number of points for an arbitrary track in a given detector

Parameters

iDet	Detector unique identifier
iTrack	Track number

Definition at line 386 of file ShipStack.cxx.

{
  if ( iTrack < 0 ) { return; }
  Int_t iDet = detId;
  pair<Int_t, Int_t> a(iTrack, iDet);
  if ( fPointsMap.find(a) == fPointsMap.end() ) { fPointsMap[a] = 1; }
  else { fPointsMap[a]++; }
}

FillTrackArray()

void ShipStack::FillTrackArray ( )

virtual

Fill the MCTrack output array, applying filter criteria

Definition at line 224 of file ShipStack.cxx.

{
 
  LOG(DEBUG) << "ShipStack: Filling MCTrack array...";
 
  // --> Reset index map and number of output tracks
  fIndexMap.clear();
  fNTracks = 0;
 
  // --> Check tracks for selection criteria
  SelectTracks();
 
  // --> Loop over fParticles array and copy selected tracks
  for (Int_t iPart=0; iPart<fNParticles; iPart++) {
 
    fStoreIter = fStoreMap.find(iPart);
    if (fStoreIter == fStoreMap.end() ) {
      LOGF(fatal, "ShipStack: Particle %i not found in storage map! ", iPart);
    }
    Bool_t store = (*fStoreIter).second;
 
    if (store) {
      ShipMCTrack* track =
        new( (*fTracks)[fNTracks]) ShipMCTrack(GetParticle(iPart));
      fIndexMap[iPart] = fNTracks;
      // --> Set the number of points in the detectors for this track
      for (Int_t iDet = kEmulsionDet; iDet < kEndOfList; iDet++) {
        pair<Int_t, Int_t> a(iPart, iDet);
        track->SetNPoints(iDet, fPointsMap[a]);
      }
      fNTracks++;
    } else { fIndexMap[iPart] = -2; }
 
  }
 
  // --> Map index for primary mothers
  fIndexMap[-1] = -1;
 
  // --> Screen output
  //Print(1);
 
}

GetCurrentParentTrackNumber()

Int_t ShipStack::GetCurrentParentTrackNumber ( ) const

virtual

Get the track number of the parent of the current track Declared in TVirtualMCStack

Definition at line 400 of file ShipStack.cxx.

{
  TParticle* currentPart = GetCurrentTrack();
  if ( currentPart ) { return currentPart->GetFirstMother(); }
  else { return -1; }
}

GetCurrentTrack()

TParticle * ShipStack::GetCurrentTrack ( ) const

virtual

Get the current track's particle Declared in TVirtualMCStack

Definition at line 198 of file ShipStack.cxx.

{
  TParticle* currentPart = GetParticle(fCurrentTrack);
  if ( ! currentPart) {
    LOG(warn) << "ShipStack: Current track not found in stack!";
  }
  return currentPart;
}

GetCurrentTrackNumber()

virtual Int_t ShipStack::GetCurrentTrackNumber ( ) const

inlinevirtual

Get the number of the current track Declared in TVirtualMCStack

Definition at line 137 of file ShipStack.h.

{ return fCurrentTrack; }

GetListOfParticles()

TClonesArray * ShipStack::GetListOfParticles ( )

inline

Definition at line 194 of file ShipStack.h.

{ return fParticles; }

GetNprimary()

virtual Int_t ShipStack::GetNprimary ( ) const

inlinevirtual

Get number of primary tracks Declared in TVirtualMCStack

Definition at line 125 of file ShipStack.h.

{ return fNPrimaries; }

GetNtrack()

virtual Int_t ShipStack::GetNtrack ( ) const

inlinevirtual

Get total number of tracks Declared in TVirtualMCStack

Definition at line 119 of file ShipStack.h.

{ return fNParticles; }

GetParticle()

TParticle * ShipStack::GetParticle

(

Int_t

trackId

)

const

Accessors

Definition at line 411 of file ShipStack.cxx.

{
  if (trackID < 0 || trackID >= fNParticles) {
    LOGF(fatal, "ShipStack: Particle index %i out of range. Max=%i", trackID, fNParticles);
  }
  return (TParticle*)fParticles->At(trackID);
}

operator=()

ShipStack & ShipStack::operator= ( const ShipStack &  )

private

PopNextTrack()

TParticle * ShipStack::PopNextTrack ( Int_t &  iTrack )

virtual

Get next particle for tracking from the stack. Declared in TVirtualMCStack

Parameters

iTrack

index of popped track (return)

Returns

Pointer to the TParticle of the track

Definition at line 141 of file ShipStack.cxx.

{
 
  // If end of stack: Return empty pointer
  if (fStack.empty()) {
    iTrack = -1;
    return NULL;
  }
 
  // If not, get next particle from stack
  TParticle* thisParticle = fStack.top();
  fStack.pop();
 
  if ( !thisParticle) {
    iTrack = 0;
    return NULL;
  }
 
  fCurrentTrack = thisParticle->GetStatusCode();
  iTrack = fCurrentTrack;
 
  return thisParticle;
 
}

PopPrimaryForTracking()

TParticle * ShipStack::PopPrimaryForTracking ( Int_t  iPrim )

virtual

Get primary particle by index for tracking from stack Declared in TVirtualMCStack

Parameters

iPrim

index of primary particle

Returns

Pointer to the TParticle of the track

Definition at line 170 of file ShipStack.cxx.

{
 
  // Get the iPrimth particle from the fStack TClonesArray. This
  // should be a primary (if the index is correct).
 
  // Test for index
  if (iPrim < 0 || iPrim >= fNPrimaries) {
    LOGF(fatal, "ShipStack: Primary index out of range! %i ", iPrim);
  }
 
  // Return the iPrim-th TParticle from the fParticle array. This should be
  // a primary.
  TParticle* part = (TParticle*)fParticles->At(iPrim);
  /* do not understand the logic behind this !!! TR July 2014
    if ( ! (part->GetMother(0) < 0) ) {
    fLogger->Fatal(MESSAGE_ORIGIN, "ShipStack:: Not a primary track! %i ",iPrim);
    Fatal("ShipStack::PopPrimaryForTracking", "Not a primary track");
  }*/
  if(!part->TestBit(kDoneBit)) return NULL;
  else return part;
 
}

Print()

void ShipStack::Print ( Int_t  iVerbose = 0 ) const

virtual

Output to screen

Parameters

iVerbose

0=events summary, 1=track info

Definition at line 354 of file ShipStack.cxx.

{
  cout << "-I- ShipStack: Number of primaries        = "
       << fNPrimaries << endl;
  cout << "              Total number of particles  = "
       << fNParticles << endl;
  cout << "              Number of tracks in output = "
       << fNTracks << endl;
  if (iVerbose) {
    for (Int_t iTrack=0; iTrack<fNTracks; iTrack++) {
      ((ShipMCTrack*) fTracks->At(iTrack))->Print(iTrack);
    }
  }
}

PushTrack() [1/2]

void ShipStack::PushTrack ( Int_t  toBeDone, Int_t  parentID, Int_t  pdgCode, Double_t  px, Double_t  py, Double_t  pz, Double_t  e, Double_t  vx, Double_t  vy, Double_t  vz, Double_t  time, Double_t  polx, Double_t  poly, Double_t  polz, TMCProcess  proc, Int_t &  ntr, Double_t  weight, Int_t  is  )

virtual

Add a TParticle to the stack. Declared in TVirtualMCStack

Parameters

toBeDone	Flag for tracking
parentID	Index of mother particle
pdgCode	Particle type (PDG encoding)
px,py,pz	Momentum components at start vertex [GeV]
e	Total energy at start vertex [GeV]
vx,vy,vz	Coordinates of start vertex [cm]
time	Start time of track [s]
polx,poly,polz	Polarisation vector
proc	Production mechanism (VMC encoding)
ntr	Track number (filled by the stack)
weight	Particle weight
is	Generation status code (whatever that means)

Definition at line 69 of file ShipStack.cxx.

{
 
  PushTrack( toBeDone, parentId, pdgCode,
             px,  py,  pz,
             e,  vx,  vy,  vz,
             time,  polx,  poly,
             polz, proc, ntr,
             weight, is, -1);
}

PushTrack() [2/2]

void ShipStack::PushTrack ( Int_t  toBeDone, Int_t  parentID, Int_t  pdgCode, Double_t  px, Double_t  py, Double_t  pz, Double_t  e, Double_t  vx, Double_t  vy, Double_t  vz, Double_t  time, Double_t  polx, Double_t  poly, Double_t  polz, TMCProcess  proc, Int_t &  ntr, Double_t  weight, Int_t  is, Int_t  secondParentId  )

virtual

Definition at line 88 of file ShipStack.cxx.

{
 // cout << "ShipStack:  " << fNParticles << " " << pdgCode << " " << parentId <<    " " << secondparentID<<" "<<proc<< endl;
 
  // --> Get TParticle array
  TClonesArray& partArray = *fParticles;
 
  // --> Create new TParticle and add it to the TParticle array
  Int_t trackId = fNParticles;
  Int_t nPoints = 0;
  Int_t daughter1Id = -1;
  Int_t daughter2Id = -1;
  TParticle* particle =
    new(partArray[fNParticles++]) TParticle(pdgCode, trackId, parentId,nPoints, 
        daughter1Id, daughter2Id, px, py, pz, e, vx, vy, vz, time);
// from root, how does this fit ? misuse of status and mother2 ??? status is used for trackID definetely 
// TParticle(Int_t pdg, Int_t status, Int_t mother1, Int_t mother2, 
//   Int_t daughter1, Int_t daughter2, Double_t px, Double_t py, Double_t pz, Double_t etot, Double_t vx, Double_t vy, Double_t vz, Double_t time)
  particle->SetPolarisation(polx, poly, polz);
  particle->SetWeight(weight);
  particle->SetUniqueID(proc);
// TR August 2014, still trying to understand the logic of FairRoot, due to misuse of secondparentID, all is a big mess
  if (parentId < 0){ 
     particle->SetFirstMother(secondparentID);
     particle->SetLastMother(secondparentID);
  }
  else {            
      particle->SetFirstMother(parentId);  
      particle->SetLastMother(parentId);  
  }
  // --> Increment counter
  if (parentId < 0) { fNPrimaries++; }
 
  // --> Set argument variable
  ntr = trackId;
 
  // --> Push particle on the stack if toBeDone is set
  if (toBeDone == 1) {
      particle->SetBit(kDoneBit);
      fStack.push(particle);
  }
 
}

Register()

void ShipStack::Register ( )

virtual

Register the MCTrack array to the Root Manager

Definition at line 345 of file ShipStack.cxx.

{
  FairRootManager::Instance()->Register("MCTrack", "Stack", fTracks,kTRUE);
}

Reset()

void ShipStack::Reset ( )

virtual

Resets arrays and stack and deletes particles and tracks

Definition at line 330 of file ShipStack.cxx.

{
  fIndex = 0;
  fCurrentTrack = -1;
  fNPrimaries = fNParticles = fNTracks = 0;
  while (! fStack.empty() ) { fStack.pop(); }
  fParticles->Clear();
  fTracks->Clear();
  fPointsMap.clear();
}

SelectTracks()

void ShipStack::SelectTracks ( )

private

Mark tracks for output using selection criteria

Definition at line 423 of file ShipStack.cxx.

{
 
  // --> Clear storage map
  fStoreMap.clear();
 
  // --> Check particles in the fParticle array
  for (Int_t i=0; i<fNParticles; i++) {
 
    TParticle* thisPart = GetParticle(i);
    Bool_t store = kTRUE;
 
    // --> Get track parameters
    Int_t iMother   = thisPart->GetMother(0);
    TLorentzVector p;
    thisPart->Momentum(p);
    Double_t energy = p.E();
    Double_t mass   = p.M();
//    Double_t mass   = thisPart->GetMass();
    Double_t eKin = energy - mass;
 
    // --> Calculate number of points
    Int_t nPoints = 0;
    for (Int_t iDet = kEmulsionDet; iDet < kEndOfList; iDet++) {
      pair<Int_t, Int_t> a(i, iDet);
      if ( fPointsMap.find(a) != fPointsMap.end() ) {
        nPoints += fPointsMap[a];
      }
    }
 
    // --> Check for cuts (store primaries in any case)
    if (iMother < 0) { store = kTRUE; }
    else {
      if (!fStoreSecondaries) { store = kFALSE; }
      if (nPoints < fMinPoints) { store = kFALSE; }
      if (eKin < fEnergyCut) { store = kFALSE; }
      if ((nPoints >= fMinPoints && fMinPoints > 0) || (eKin >= fEnergyCut && fEnergyCut > 0)) {
         store=kTRUE;
      }
    }
    // --> Set storage flag
    fStoreMap[i] = store;
// special case for Ship generators, want to keep all original particles with their mother daughter relationship 
// independent if tracked or not. apply a dirty trick and use second mother to identify original generator particles. 
// doesn't work, always true: Int_t iMother2 = GetParticle(i)->GetMother(1); maybe should set Mother2 to -1 in the generator
// if (iMother == iMother2) {fStoreMap[i] = kTRUE;}
  }
  // --> If flag is set, flag recursively mothers of selected tracks
  if (fStoreMothers) {
    for (Int_t i=0; i<fNParticles; i++) {
      if (fStoreMap[i]) {
        Int_t iMother  = GetParticle(i)->GetMother(0);
    {
          while(iMother >= 0)
      {
            fStoreMap[iMother] = kTRUE;
            iMother = GetParticle(iMother)->GetMother(0);
          }
       }
      }
    }
  }
 
}

SetCurrentTrack()

virtual void ShipStack::SetCurrentTrack ( Int_t  iTrack )

inlinevirtual

Set the current track number Declared in TVirtualMCStack

Parameters

iTrack

track number

Definition at line 113 of file ShipStack.h.

{ fCurrentTrack     = iTrack; }

SetEnergyCut()

void ShipStack::SetEnergyCut ( Double_t  eMin )

inline

Definition at line 175 of file ShipStack.h.

{ fEnergyCut        = eMin;   }

SetMinPoints()

void ShipStack::SetMinPoints ( Int_t  min )

inline

Definition at line 174 of file ShipStack.h.

{ fMinPoints        = min;    }

StoreMothers()

void ShipStack::StoreMothers ( Bool_t  choice = kTRUE )

inline

Definition at line 176 of file ShipStack.h.

{ fStoreMothers     = choice; }

StoreSecondaries()

void ShipStack::StoreSecondaries ( Bool_t  choice = kTRUE )

inline

Modifiers

Definition at line 173 of file ShipStack.h.

{ fStoreSecondaries = choice; }

UpdateTrackIndex()

void ShipStack::UpdateTrackIndex ( TRefArray *  detArray = 0 )

virtual

Update the track index in the MCTracks and MCPoints

Definition at line 271 of file ShipStack.cxx.

{
 
  LOG(DEBUG) << "ShipStack: Updating track indizes...";
  Int_t nColl = 0;
 
  // First update mother ID in MCTracks
  for (Int_t i=0; i<fNTracks; i++) {
    ShipMCTrack* track = (ShipMCTrack*)fTracks->At(i);
    Int_t iMotherOld = track->GetMotherId();
    fIndexIter = fIndexMap.find(iMotherOld);
    if (fIndexIter == fIndexMap.end()) {
      LOGF(fatal, "ShipStack: Particle index %i not found in dex map! ", iMotherOld);
    }
    track->SetMotherId( (*fIndexIter).second );
  }
 
 
  if(fDetList==0) {
    // Now iterate through all active detectors
    fDetIter = detList->MakeIterator();
    fDetIter->Reset();
  } else {
    fDetIter->Reset();
  }
 
  FairDetector* det = NULL;
  while( (det = (FairDetector*)fDetIter->Next() ) ) {
 
 
    // --> Get hit collections from detector
    Int_t iColl = 0;
    TClonesArray* hitArray;
    while ( (hitArray = det->GetCollection(iColl++)) ) {
      nColl++;
      Int_t nPoints = hitArray->GetEntriesFast();
 
      // --> Update track index for all MCPoints in the collection
      for (Int_t iPoint=0; iPoint<nPoints; iPoint++) {
        FairMCPoint* point = (FairMCPoint*)hitArray->At(iPoint);
        Int_t iTrack = point->GetTrackID();
 
        fIndexIter = fIndexMap.find(iTrack);
        if (fIndexIter == fIndexMap.end()) {
          LOGF(fatal, "ShipStack: Particle index %i not found in index map! ", iTrack);
        }
        point->SetTrackID((*fIndexIter).second);
        point->SetLink(FairLink("MCTrack", (*fIndexIter).second));
      }
 
    }   // Collections of this detector
  }     // List of active detectors
  LOGF(debug, "...stack and  %i collections updated.", nColl);
}

Member Data Documentation

fCurrentTrack

Int_t ShipStack::fCurrentTrack

private

Some indizes and counters

Definition at line 229 of file ShipStack.h.

fEnergyCut

Double32_t ShipStack::fEnergyCut

private

Definition at line 239 of file ShipStack.h.

fIndex

Int_t ShipStack::fIndex

private

Number of entries in fTracks.

Definition at line 233 of file ShipStack.h.

fIndexIter

std::map<Int_t,Int_t>::iterator ShipStack::fIndexIter

private

Definition at line 221 of file ShipStack.h.

fIndexMap

std::map<Int_t, Int_t> ShipStack::fIndexMap

private

STL map from particle index to track index

Definition at line 220 of file ShipStack.h.

fMinPoints

Int_t ShipStack::fMinPoints

private

Definition at line 238 of file ShipStack.h.

fNParticles

Int_t ShipStack::fNParticles

private

Number of primary particles.

Definition at line 231 of file ShipStack.h.

fNPrimaries

Int_t ShipStack::fNPrimaries

private

Index of current track.

Definition at line 230 of file ShipStack.h.

fNTracks

Int_t ShipStack::fNTracks

private

Number of entries in fParticles.

Definition at line 232 of file ShipStack.h.

fParticles

TClonesArray* ShipStack::fParticles

private

Array of TParticles (contains all TParticles put into or created by the transport

Definition at line 207 of file ShipStack.h.

fPointsMap

std::map<std::pair<Int_t, Int_t>, Int_t> ShipStack::fPointsMap

private

STL map from track index and detector ID to number of MCPoints

Definition at line 225 of file ShipStack.h.

fStack

std::stack<TParticle*> ShipStack::fStack

private

STL stack (FILO) used to handle the TParticles for tracking

Definition at line 201 of file ShipStack.h.

fStoreIter

std::map<Int_t,Bool_t>::iterator ShipStack::fStoreIter

private

Definition at line 216 of file ShipStack.h.

fStoreMap

std::map<Int_t, Bool_t> ShipStack::fStoreMap

private

STL map from particle index to storage flag

Definition at line 215 of file ShipStack.h.

fStoreMothers

Bool_t ShipStack::fStoreMothers

private

Definition at line 240 of file ShipStack.h.

fStoreSecondaries

Bool_t ShipStack::fStoreSecondaries

private

Used for merging.

Variables defining the criteria for output selection

Definition at line 237 of file ShipStack.h.

fTracks

TClonesArray* ShipStack::fTracks

private

Array of FairMCTracks containg the tracks written to the output

Definition at line 211 of file ShipStack.h.

---

The documentation for this class was generated from the following files:

• shipdata/ShipStack.h
• shipdata/ShipStack.cxx