CbmStack.h

Go to the documentation of this file.

// -------------------------------------------------------------------------
// -----                       CbmStack header file                    -----
// -----           Created 10/08/04  by D. Bertini / V. Friese         -----
// -------------------------------------------------------------------------
 
#ifndef CBMSTACK_H
#define CBMSTACK_H
 
#include "BmnDetectorList.h"    // for DetectorId
#include "FairGenericStack.h"   // for FairGenericStack
 
#include <TMCProcess.h>         // for TMCProcess
#include <TParticle.h>          // for TParticle
#include <TClonesArray.h>       // for TClonesArray
#include <TRefArray.h>          // for TRefArray
 
#include <map>                  // for map, map<>::iterator
#include <stack>                // for stack
#include <utility>              // for pair
 
class CbmStack : public FairGenericStack
{
  public:
    CbmStack(Int_t size = 100);
 
    virtual ~CbmStack();
 
    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) { fCurrentTrack = iTrack; }
 
    virtual Int_t GetNtrack() const { return fNParticles; }
 
    virtual Int_t GetNprimary() const { return fNPrimaries; }
 
    virtual TParticle* GetCurrentTrack() const;
 
    virtual Int_t GetCurrentTrackNumber() const { return fCurrentTrack; }
 
    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(Option_t*) const;
 
    void StoreSecondaries(Bool_t choice = kTRUE) { fStoreSecondaries = choice; }
    void SetMinPoints(Int_t min) { fMinPoints = min; }
    void SetEnergyCut(Double_t eMin) { fEnergyCut = eMin; }
    void SetStartZCut(Double_t zMax) { fStartZCut = zMax; }
    void StoreMothers(Bool_t choice = kTRUE) { fStoreMothers = choice; }
 
    void AddPoint(DetectorId iDet);
 
    void AddPoint(DetectorId iDet, Int_t iTrack);
 
    TParticle* GetParticle(Int_t trackId) const;
    TClonesArray* GetListOfParticles() { return fParticles; }
 
    void SetParticleArray(TClonesArray* partArray)
    {
        for (Int_t ipart = 0; ipart < partArray->GetEntries(); ipart++) {
            ((TParticle*)(partArray->At(ipart)))->SetUniqueID(fNPrimaries);
            fStack.push((TParticle*)partArray->At(ipart));
            AddParticle((TParticle*)partArray->At(ipart));
            fNParticles++;
            fNPrimaries++;
        }
    }
 
    void SetParticleArray(TClonesArray* partArray, Int_t partFrom, Int_t partTo)
    {
        for (Int_t ipart = partFrom; ipart < partTo; ipart++) {
            ((TParticle*)(partArray->At(ipart)))->SetUniqueID(fNPrimaries);
            ((TParticle*)(partArray->At(ipart)))->SetStatusCode(fNPrimaries);
            fStack.push((TParticle*)partArray->At(ipart));
            AddParticle((TParticle*)partArray->At(ipart));
            fNParticles++;
            fNPrimaries++;
        }
    }
 
    virtual FairGenericStack* CloneStack() const
    {
        CbmStack* clonedStack = new CbmStack();
        clonedStack->StoreSecondaries(fStoreSecondaries);
        clonedStack->SetMinPoints(fMinPoints);
        clonedStack->SetEnergyCut(fEnergyCut);
        clonedStack->StoreMothers(fStoreMothers);
        return clonedStack;
    }
 
  private:
    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;     
    Int_t fNParticles;     
    Int_t fNTracks;        
    Int_t fIndex;          
 
    Bool_t fStoreSecondaries;
    Int_t fMinPoints;
    Double32_t fEnergyCut;
    Double_t   fStartZCut;
    Bool_t fStoreMothers;
 
    void SelectTracks();
 
    CbmStack(const CbmStack&);
    CbmStack& operator=(const CbmStack&);
 
    ClassDef(CbmStack, 2);
};
 
#endif