FairTrajFilter.h

Go to the documentation of this file.

/********************************************************************************
 *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
 *                                                                              *
 *              This software is distributed under the terms of the             *
 *              GNU Lesser General Public Licence (LGPL) version 3,             *
 *                  copied verbatim in the file "LICENSE"                       *
 ********************************************************************************/
// ********************************************* //
// ***        D. Kresan   2004-Sep-14        *** //
// ***        D.Kresan@gsi.de                *** //
// ********************************************* //

#ifndef FAIR_TRAJ_FILTER_H
#define FAIR_TRAJ_FILTER_H 1

#include <Rtypes.h>      // for Double_t, Bool_t, Int_t, etc
#include <TGeoTrack.h>   // IWYU pragma: keep needed by cint // TODO: is this still relevant for CINT?
#include <TMCtls.h>      // for multi-threading
#include <TMath.h>       // for Pi, TwoPi
#include <TString.h>     // for TString

class TClonesArray;
class TParticle;

class FairTrajFilter
{
  public:
    FairTrajFilter();

    virtual ~FairTrajFilter();

    ClassDef(FairTrajFilter, 1);

  private:
    FairTrajFilter(const FairTrajFilter&);
    FairTrajFilter& operator=(const FairTrajFilter&);

    static TMCThreadLocal FairTrajFilter* fgInstance;

    Double_t fVxMin;
    Double_t fVxMax;
    Double_t fVyMin;
    Double_t fVyMax;
    Double_t fVzMin;
    Double_t fVzMax;

    Double_t fPMin;
    Double_t fPMax;
    Double_t fThetaMin;
    Double_t fThetaMax;
    Double_t fPhiMin;
    Double_t fPhiMax;

    Double_t fPxMin;
    Double_t fPxMax;
    Double_t fPyMin;
    Double_t fPyMax;
    Double_t fPzMin;
    Double_t fPzMax;

    Double_t fPtMin;
    Double_t fPtMax;
    Double_t fRapidityMin;
    Double_t fRapidityMax;

    Int_t fKinCutType;

    Double_t fEtotMin;
    Double_t fEtotMax;

    Bool_t fStorePrim;
    Bool_t fStoreSec;

    Double_t fStepSizeMin;

    TClonesArray* fTrackCollection;

    TGeoTrack* fCurrentTrk;

  public:
    TGeoTrack* AddTrack(Int_t trackId, Int_t pdgCode);
    TGeoTrack* AddTrack(TParticle* p);
    TGeoTrack* CheckAddTrack(Int_t trackId, TParticle* p);
    TGeoTrack* GetCurrentTrk() { return fCurrentTrk; }

    void Init(TString brName = "GeoTracks", TString folderName = "MCGeoTrack");
    void Reset();
    static FairTrajFilter* Instance();

    Bool_t IsAccepted(const TParticle* p) const;

    void SetVertexCut(Double_t vxMin = -2000.,
                      Double_t vyMin = -2000.,
                      Double_t vzMin = -2000.,
                      Double_t vxMax = 2000.,
                      Double_t vyMax = 2000.,
                      Double_t vzMax = 2000.);

    void SetMomentumCutP(Double_t pMin = 0.,
                         Double_t thetaMin = 0.,
                         Double_t phiMin = 0.,
                         Double_t pMax = 1e10,
                         Double_t thetaMax = TMath::Pi(),
                         Double_t phiMax = TMath::TwoPi());

    void SetMomentumCutD(Double_t pxMin = -1e10,
                         Double_t pyMin = -1e10,
                         Double_t pzMin = -1e10,
                         Double_t pxMax = 1e10,
                         Double_t pyMax = 1e10,
                         Double_t pzMax = 1e10);

    void SetPtRapidityCut(Double_t ptMin = 0.,
                          Double_t ptMax = 1e10,
                          Double_t rapidityMin = -1e10,
                          Double_t rapidityMax = 1e10);

    void SetEnergyCut(Double_t etotMin = 0., Double_t etotMax = 1e10);

    inline void SetStorePrimaries(Bool_t storePrim = kTRUE) { fStorePrim = storePrim; };

    inline void SetStoreSecondaries(Bool_t storeSec = kTRUE) { fStoreSec = storeSec; };

    void SetStepSizeCut(Double_t stepSizeMin = 0.);

    void GetVertexCut(Double_t& vxMin,
                      Double_t& vyMin,
                      Double_t& vzMin,
                      Double_t& vxMax,
                      Double_t& vyMax,
                      Double_t& vzMax) const;

    void GetMomentumCutP(Double_t& pMin,
                         Double_t& thetaMin,
                         Double_t& phiMin,
                         Double_t& pMax,
                         Double_t& thetaMax,
                         Double_t& phiMax) const;

    void GetMomentumCutD(Double_t& pxMin,
                         Double_t& pyMin,
                         Double_t& pzMin,
                         Double_t& pxMax,
                         Double_t& pyMax,
                         Double_t& pzMax) const;

    void GetPtRapidityCut(Double_t& ptMin, Double_t& ptMax, Double_t& rapidityMin, Double_t& rapidityMax) const;

    void GetEnergyCut(Double_t& etotMin, Double_t& etotMax) const;

    inline Bool_t IsPrimariesStored() const { return fStorePrim; };

    inline Bool_t IsSecondariesStored() const { return fStoreSec; };

    inline Double_t GetStepSizeCut() const { return fStepSizeMin; };

    TGeoTrack* GetTrack(Int_t trackId);
};

#endif