CaToolsMCTrack.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 CaToolsMCTrack_h
#define CaToolsMCTrack_h 1
 
#include "CaToolsDef.h"
#include "CaToolsLinkKey.h"
#include "CaVector.h"
#include "CbmL1Hit.h"
#include "TMath.h"
 
#include <functional>
 
class CbmL1HitDebugInfo;
 
namespace cbm::ca::tools
{
  class MCPoint;
 
  namespace constants = cbm::algo::ca::constants;
 
  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; }
 
    LinkKey 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<CbmL1HitDebugInfo>& 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>;  
 
    LinkKey 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::ca::tools
 
#endif  // CaToolsMCTrack_h