R3BMCStack.h

Go to the documentation of this file.

/******************************************************************************
 *   Copyright (C) 2019 GSI Helmholtzzentrum für Schwerionenforschung GmbH    *
 *   Copyright (C) 2019-2025 Members of R3B Collaboration                     *
 *                                                                            *
 *             This software is distributed under the terms of the            *
 *                 GNU General Public Licence (GPL) version 3,                *
 *                    copied verbatim in the file "LICENSE".                  *
 *                                                                            *
 * In applying this license GSI does not waive the privileges and immunities  *
 * granted to it by virtue of its status as an Intergovernmental Organization *
 * or submit itself to any jurisdiction.                                      *
 ******************************************************************************/
 
// -------------------------------------------------------------------------
// -----                       R3BStack header file                    -----
// -----           Created 10/08/04  by D. Bertini / V. Friese         -----
// -------------------------------------------------------------------------

 
#ifndef R3BSTACK_H
#define R3BSTACK_H
 
#include "FairGenericStack.h"
#include "R3BDetectorList.h"
 
#include "TClonesArray.h"
#include "TVirtualMCStack.h"
 
#include <array>
#include <map>
#include <stack>
 
class R3BStack : public FairGenericStack
{
 
  public:
    R3BStack(Int_t size = 100);

    virtual ~R3BStack();

    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);

    virtual void Reset();

    virtual void Register();

    virtual void PrintStack(Int_t iVerbose) const;

    void StoreSecondaries(Bool_t choice = kTRUE) { fStoreSecondaries = choice; }
    void SetMinPoints(Int_t min) { fMinPoints = min; }
    void SetEnergyCut(Double_t eMin) { fEnergyCut = eMin; }
    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 SetDebug(Bool_t t) { fDebug = t; }
 
  private:
    R3BStack(const R3BStack&);
    R3BStack& operator=(const R3BStack&) { return *this; }

    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<int, std::array<int, kLAST + 1>> fPointsMap; 

    Int_t fCurrentTrack; 
    Int_t fNPrimaries;   
    Int_t fNParticles;   
    Int_t fNTracks;      
    Int_t fIndex;        
    Int_t fMC;           

    Bool_t fStoreSecondaries;
    Int_t fMinPoints;
    Double32_t fEnergyCut;
    Bool_t fStoreMothers;
    Bool_t fDebug;

    void SelectTracks();
 
    ClassDef(R3BStack, 1)
};
 
#endif