CaToolsMCPoint.h

Go to the documentation of this file.

/* Copyright (C) 2022 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */
 
 
#ifndef CaToolsMCPoint_h
#define CaToolsMCPoint_h 1
 
#include "CaToolsDef.h"
#include "CaToolsLinkKey.h"
#include "CaVector.h"
 
#include <string>
 
using namespace cbm::algo::ca;  //TODO: remove
 
namespace cbm::algo::ca
{
  enum class EDetectorID;
}
 
namespace cbm::ca::tools
{
  namespace constants = cbm::algo::ca::constants;
  namespace phys      = cbm::algo::ca::constants::phys;
 
  class MCPoint {
   public:
    MCPoint() = default;
 
    ~MCPoint() = default;
 
    MCPoint(const MCPoint&) = default;
 
    MCPoint(MCPoint&&) = default;
 
    MCPoint& operator=(const MCPoint&) = default;
 
    MCPoint& operator=(MCPoint&&) = default;
 
 
    void AddHitID(int iH) { fvHitIndexes.push_back_no_warning(iH); }
 
 
    // *********************
    // **     Getters     **
    // *********************
 
    double GetCharge() const { return fCharge; }
 
    ca::EDetectorID GetDetectorId() const { return fDetectorId; }
 
    int GetEventId() const { return fLinkKey.fEvent; }
 
    int GetExternalId() const { return fLinkKey.fIndex; }
 
    int GetFileId() const { return fLinkKey.fFile; }
 
    int GetId() const { return fId; }
 
    int GetInvSpeed() const { return std::sqrt(1. + GetMass() * GetMass() / GetP() / GetP()) * phys::SpeedOfLightInv; }
 
    int GetInvSpeedIn() const
    {
      return std::sqrt(1. + GetMass() * GetMass() / GetPIn() / GetPIn()) * phys::SpeedOfLightInv;
    }
 
    int GetInvSpeedOut() const
    {
      return std::sqrt(1. + GetMass() * GetMass() / GetPOut() / GetPOut()) * phys::SpeedOfLightInv;
    }
 
    const auto& GetHitIndexes() const { return fvHitIndexes; }
 
    LinkKey GetLinkKey() const { return fLinkKey; }
 
    double GetMass() const { return fMass; }
 
    int GetMotherId() const { return fMotherId; }
 
    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]); }
 
    double GetPhiIn() const { return std::atan2(-fMomIn[1], fMomIn[0]); }
 
    double GetPhiOut() const { return std::atan2(-fMomOut[1], fMomOut[0]); }
 
    double GetPIn() const { return std::sqrt(fMomIn[0] * fMomIn[0] + fMomIn[1] * fMomIn[1] + fMomIn[2] * fMomIn[2]); }
 
    double GetPOut() const
    {
      return std::sqrt(fMomOut[0] * fMomOut[0] + fMomOut[1] * fMomOut[1] + fMomOut[2] * fMomOut[2]);
    }
 
    double GetPt() const { return sqrt(fMom[0] * fMom[0] + fMom[1] * fMom[1]); }
 
    double GetPtIn() const
    {
      return sqrt(fMomIn[0] * fMomIn[0] + fMomIn[1] * fMomIn[1]);
      ;
    }
 
    double GetPtOut() const
    {
      return sqrt(fMomOut[0] * fMomOut[0] + fMomOut[1] * fMomOut[1]);
      ;
    }
 
 
    double GetPx() const { return fMom[0]; }
 
    double GetPxIn() const { return fMomIn[0]; }
 
    double GetPxOut() const { return fMomOut[0]; }
 
    double GetPy() const { return fMom[1]; }
 
    double GetPyIn() const { return fMomIn[1]; }
 
    double GetPyOut() const { return fMomOut[1]; }
 
    double GetPz() const { return fMom[2]; }
 
    double GetPzIn() const { return fMomIn[2]; }
 
    double GetPzOut() const { return fMomOut[2]; }
 
    double GetQp() const { return fCharge / GetP(); }
 
    double GetQpIn() const { return fCharge / GetPIn(); }
 
    double GetQpOut() const { return fCharge / GetPOut(); }
 
    int GetStationId() const { return fStationId; }
 
    double GetTheta() const { return std::acos(GetPz() / GetP()); }
 
    double GetThetaIn() const { return std::acos(GetPzIn() / GetPIn()); }
 
    double GetThetaOut() const { return std::acos(GetPzOut() / GetPOut()); }
 
    double GetTime() const { return fTime; }
 
    int GetTrackId() const { return fTrackId; }
 
    double GetTx() const { return fMom[0] / fMom[2]; }
 
    double GetTxIn() const { return fMomIn[0] / fMomIn[2]; }
 
    double GetTxOut() const { return fMomOut[0] / fMomOut[2]; }
 
    double GetTy() const { return fMom[1] / fMom[2]; }
 
    double GetTyIn() const { return fMomIn[1] / fMomIn[2]; }
 
    double GetTyOut() const { return fMomOut[1] / fMomOut[2]; }
 
    double GetX() const { return fPos[0]; }
 
    double GetXIn() const { return fPosIn[0]; }
 
    double GetXOut() const { return fPosOut[0]; }
 
    double GetY() const { return fPos[1]; }
 
    double GetYIn() const { return fPosIn[1]; }
 
    double GetYOut() const { return fPosOut[1]; }
 
    double GetZ() const { return fPos[2]; }
 
    double GetZIn() const { return fPosIn[2]; }
 
    double GetZOut() const { return fPosOut[2]; }
 
    // *********************
    // **     Setters     **
    // *********************
 
    void SetCharge(double charge) { fCharge = charge; }
 
    void SetDetectorId(ca::EDetectorID detId) { fDetectorId = detId; }
 
    void SetEventId(int eventId) { fLinkKey.fEvent = eventId; }
 
    void SetExternalId(int id) { fLinkKey.fIndex = id; }
 
    void SetFileId(int fileId) { fLinkKey.fFile = fileId; }
 
    void SetId(int id) { fId = id; }
 
    void SetMass(double mass) { fMass = mass; }
 
    void SetMotherId(int motherId) { fMotherId = motherId; }
 
    void SetPdgCode(int pdg) { fPdgCode = pdg; }
 
    void SetPx(double px) { fMom[0] = px; }
 
    void SetPxIn(double px) { fMomIn[0] = px; }
 
    void SetPxOut(double px) { fMomOut[0] = px; }
 
    void SetPy(double py) { fMom[1] = py; }
 
    void SetPyIn(double py) { fMomIn[1] = py; }
 
    void SetPyOut(double py) { fMomOut[1] = py; }
 
    void SetPz(double pz) { fMom[2] = pz; }
 
    void SetPzIn(double pz) { fMomIn[2] = pz; }
 
    void SetPzOut(double pz) { fMomOut[2] = pz; }
 
 
    void SetStationId(int stationId) { fStationId = stationId; }
 
    void SetTime(double time) { fTime = time; }
 
    void SetTrackId(int trackId) { fTrackId = trackId; }
 
    void SetX(double x) { fPos[0] = x; }
 
    void SetXIn(double x) { fPosIn[0] = x; }
 
    void SetXOut(double x) { fPosOut[0] = x; }
 
    void SetY(double y) { fPos[1] = y; }
 
    void SetYIn(double y) { fPosIn[1] = y; }
 
    void SetYOut(double y) { fPosOut[1] = y; }
 
    void SetZ(double z) { fPos[2] = z; }
 
    void SetZIn(double z) { fPosIn[2] = z; }
 
    void SetZOut(double z) { fPosOut[2] = z; }
 
    std::string ToString(int verbose, bool printHeader = false) const;
 
    // ****************************
    // **     Data variables     **
    // ****************************
 
   private:
    std::array<double, 3> fPos = {constants::Undef<double>, constants::Undef<double>, constants::Undef<double>};
    std::array<double, 3> fPosIn = {constants::Undef<double>, constants::Undef<double>, constants::Undef<double>};
    std::array<double, 3> fPosOut = {constants::Undef<double>, constants::Undef<double>, constants::Undef<double>};
    std::array<double, 3> fMom = {constants::Undef<double>, constants::Undef<double>, constants::Undef<double>};
    std::array<double, 3> fMomIn = {constants::Undef<double>, constants::Undef<double>, constants::Undef<double>};
    std::array<double, 3> fMomOut = {constants::Undef<double>, constants::Undef<double>, constants::Undef<double>};
 
    double fMass   = constants::Undef<double>;  
    double fCharge = constants::Undef<double>;  
    double fTime   = constants::Undef<double>;  
 
    LinkKey fLinkKey = {constants::Undef<int>, constants::Undef<int>, constants::Undef<int>};  
 
    int fPdgCode = constants::Undef<int>;  
    int fId      = constants::Undef<int>;  
    int fTrackId =
      constants::Undef<int>;  
    int fMotherId  = constants::Undef<int>;  
    int fStationId = constants::Undef<int>;  
 
    ca::EDetectorID fDetectorId;  
 
    // TODO: SZh 17.05.2023: Check, if there are more then one index can be added
    ca::Vector<int> fvHitIndexes{"ca::tools::MCPoint::fvHitIndexes"};  
  };
}  // namespace cbm::ca::tools
 
 
#endif  // CaToolsMCPoint_h