CaMcTrack.h

Go to the documentation of this file.

/* Copyright (C) 2022 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergey Gorbunov, Sergei Zharko [committer] */

 
#ifndef CaMcTrack_h
#define CaMcTrack_h 1
 
#include "CaDefs.h"
#include "CaMcLinkKey.h"
#include "CaVector.h"
 
#include <functional>
 
namespace cbm::algo::ca
{
  class McPoint;
  class McHitInfo;
 
  class McTrack {
   public:
    McTrack() = default;

    ~McTrack() = default;

    McTrack(const McTrack&) = default;

    McTrack(McTrack&&) = default;

    McTrack& operator=(const McTrack&) = default;

    McTrack& operator=(McTrack&&) = default;

    void AddPointIndex(int iP) { fvPointIndexes.push_back_no_warning(iP); }

    void AddHitIndex(int iH) { fvHitIndexes.push_back_no_warning(iH); }

    void AddRecoTrackIndex(int iTre) { fvRecoTrackIndexes.push_back_no_warning(iTre); }

    void AddTouchTrackIndex(int iTre) { fvTouchTrackIndexes.push_back_no_warning(iTre); }

    void Clear();

    void ClearPointIndexes() { fvPointIndexes.clear(); }

    void ClearHitIndexes() { fvHitIndexes.clear(); }

    void ClearRecoTrackIndexes() { fvRecoTrackIndexes.clear(); }

    void ClearTouchTrackIndexes() { fvTouchTrackIndexes.clear(); }
 
    // *********************
    // **     Getters     **
    // *********************

    int GetChainId() const { return fChainId; }

    double GetCharge() const { return fCharge; }

    double GetE() const { return std::sqrt(GetP() * GetP() + fMass * fMass); }

    double GetEkin() const { return GetE() - fMass; }

    double GetEta() const { return -std::log(std::tan(GetTheta() * 0.5)); }

    int GetEventId() const { return fLinkKey.fEvent; }

    int GetExternalId() const { return fLinkKey.fIndex; }

    int GetFileId() const { return fLinkKey.fFile; }

    const auto& GetHitIndexes() const { return fvHitIndexes; }

    int GetId() const { return fId; }

    ca::McLinkKey GetLinkKey() const { return fLinkKey; }

    double GetMass() const { return fMass; }

    int GetMaxNofHitsOnStation() const { return fMaxNofHitsOnStation; }

    int GetMaxNofPointsOnStation() const { return fMaxNofPointsOnStation; }

    int GetMotherId() const { return fMotherId; }

    int GetNofClones() const { return (fvRecoTrackIndexes.size() > 0 ? fvRecoTrackIndexes.size() - 1 : 0); }

    int GetNofConsStationsWithHit() const { return fNofConsStationsWithHit; }

    int GetNofConsStationsWithPoint() const { return fNofConsStationsWithPoint; }

    int GetNofHits() const { return fvHitIndexes.size(); }

    int GetNofPoints() const { return fvPointIndexes.size(); }

    int GetNofRecoTracks() const { return fvRecoTrackIndexes.size(); }

    int GetNofTouchTracks() const { return fvTouchTrackIndexes.size(); }

    double GetP() const { return std::sqrt(fMom[0] * fMom[0] + fMom[1] * fMom[1] + fMom[2] * fMom[2]); }

    int GetPdgCode() const { return fPdgCode; }

    double GetPhi() const { return std::atan2(fMom[1], fMom[0]); }

    const auto& GetPointIndexes() const { return fvPointIndexes; }

    unsigned GetProcessId() const { return fProcId; }

    double GetPt() const { return std::sqrt(fMom[0] * fMom[0] + fMom[1] * fMom[1]); }

    double GetPx() const { return fMom[0]; }

    double GetPy() const { return fMom[1]; }

    double GetPz() const { return fMom[2]; }

    double GetRapidity() const { return 0.5 * std::log((GetE() + fMom[2]) / (GetE() - fMom[2])); }

    const auto& GetRecoTrackIndexes() const { return fvRecoTrackIndexes; }

    double GetSpeed() const { return GetP() / GetE(); }

    double GetStartT() const { return fTime; }

    double GetStartX() const { return fPos[0]; }

    double GetStartY() const { return fPos[1]; }

    double GetStartZ() const { return fPos[2]; }

    double GetTheta() const { return std::acos(fMom[2] / GetP()); }

    int GetTotNofStationsWithHit() const { return fTotNofStationsWithHit; }

    int GetTotNofStationsWithPoint() const { return fTotNofStationsWithPoint; }

    double GetTx() const { return fMom[0] / fMom[2]; }

    double GetTy() const { return fMom[1] / fMom[2]; }

    McPoint GetVertexPoint() const;

    const auto& GetTouchTrackIndexes() const { return fvTouchTrackIndexes; }

    void InitHitsInfo(const ca::Vector<cbm::algo::ca::McHitInfo>& vHits);

    void InitPointsInfo(const ca::Vector<McPoint>& vPoints);
 
 
    // *******************
    // **     Flags     **
    // *******************

    bool IsAdditional() const { return fIsAdditional; }

    bool IsDisturbed() const { return fvTouchTrackIndexes.size(); }

    bool IsPrimary() const { return fProcId == 0; }

    bool IsReconstructable() const { return fIsReconstructable; }
 
    bool IsReconstructed() const { return fvRecoTrackIndexes.size(); }

    bool IsSignal() const { return fIsSignal; }
 
 
    // *********************
    // **     Setters     **
    // *********************

    void SetChainId(int chainId) { fChainId = chainId; }

    void SetCharge(double q) { fCharge = q; }

    void SetEventId(int iEvent) { fLinkKey.fEvent = iEvent; }

    void SetExternalId(int id) { fLinkKey.fIndex = id; }

    void SetFileId(int iFile) { fLinkKey.fFile = iFile; }

    void SetId(int id) { fId = id; }

    void SetMotherId(int motherId) { fMotherId = motherId; }

    void SetMass(double mass) { fMass = mass; }

    void SetPdgCode(int pdg) { fPdgCode = pdg; }

    void SetProcessId(unsigned procId) { fProcId = procId; }

    void SetPx(double px) { fMom[0] = px; }

    void SetPy(double py) { fMom[1] = py; }

    void SetPz(double pz) { fMom[2] = pz; }

    void SetFlagAdditional(bool isAdditional) { fIsAdditional = isAdditional; }

    void SetFlagReconstructable(bool isReconstructable) { fIsReconstructable = isReconstructable; }

    void SetFlagSignal(bool isSignal) { fIsSignal = isSignal; }

    void SetStartT(double t) { fTime = t; }

    void SetStartX(double x) { fPos[0] = x; }

    void SetStartY(double y) { fPos[1] = y; }

    void SetStartZ(double z) { fPos[2] = z; }

    void SortPointIndexes(const std::function<bool(const int& lhs, const int& rhs)>& cmpFn);

    std::string ToString(int verbose = 1, bool header = false) const;
 
   private:
    // ****************************
    // **     Data variables     **
    // ****************************
 
    double fMass   = constants::Undef<double>;  
    double fCharge = constants::Undef<double>;  
    double fTime   = constants::Undef<double>;  
 
    std::array<double, 3> fPos = {constants::Undef<double>, constants::Undef<double>,
                                  constants::Undef<double>};  
    std::array<double, 3> fMom = {constants::Undef<double>, constants::Undef<double>,
                                  constants::Undef<double>};  
 
    int fPdgCode     = constants::Undef<int>;       
    unsigned fProcId = constants::Undef<unsigned>;  
 
    // Track address
    int fId       = constants::Undef<int>;  
    int fMotherId = constants::Undef<int>;  
    int fChainId  = constants::Undef<int>;  
 
    ca::McLinkKey fLinkKey = {constants::Undef<int>, constants::Undef<int>,
                              constants::Undef<int>};  
 
    bool fIsSignal          = false;  
    bool fIsReconstructable = false;  
    bool fIsAdditional      = false;  
 
    // Arrangement of hits and points within the stations
    int fNofConsStationsWithHit   = constants::Undef<int>;  
    int fNofConsStationsWithPoint = constants::Undef<int>;  
    int fTotNofStationsWithHit    = constants::Undef<int>;  
    int fTotNofStationsWithPoint  = constants::Undef<int>;  
    int fMaxNofPointsOnStation    = constants::Undef<int>;  
    int fMaxNofPointsOnSensor = constants::Undef<int>;  
    int fMaxNofHitsOnStation  = constants::Undef<int>;  
 
    ca::Vector<int> fvPointIndexes      = {"ca::tools::fvPointIndexes"};      
    ca::Vector<int> fvHitIndexes        = {"ca::tools::fvHitIndexes"};        
    ca::Vector<int> fvRecoTrackIndexes  = {"ca::tools::fvRecoTrackIndexes"};  
    ca::Vector<int> fvTouchTrackIndexes = {"ca::tools::fvTouchTrackIndexes"};  
  };
 
}  // namespace cbm::algo::ca
 
#endif  // CaMcTrack_h