CaMcPoint.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 CaMcPoint_h
#define CaMcPoint_h 1
 
#include "CaDefs.h"
#include "CaMcLinkKey.h"
#include "CaVector.h"
//#include "CbmDefs.h"
 
#include <string>
 
using namespace cbm::algo::ca;  //TODO: remove
 
namespace cbm::algo::ca
{
  enum class EDetectorID;
}
 
namespace cbm::algo::ca
{
  namespace ca = cbm::algo::ca;

  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 GetActiveStationId() const { return fActiveStationId; }

    int GetLocalStationId() const { return fLocalStationId; }

    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()) * constants::phys::SpeedOfLightInv;
    }

    int GetInvSpeedIn() const
    {
      return std::sqrt(1. + GetMass() * GetMass() / GetPIn() / GetPIn()) * constants::phys::SpeedOfLightInv;
    }

    int GetInvSpeedOut() const
    {
      return std::sqrt(1. + GetMass() * GetMass() / GetPOut() / GetPOut()) * constants::phys::SpeedOfLightInv;
    }

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

    McLinkKey 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(); }

    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 SetActiveStationId(int stationId) { fActiveStationId = stationId; }

    void SetLocalStationId(int localStationId) { fLocalStationId = localStationId; }

    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 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>;  
 
    McLinkKey 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>;  
 
    ca::EDetectorID fDetectorId{0};  
 
    int fActiveStationId = constants::Undef<int>;  
    int fLocalStationId  = constants::Undef<int>;  
 
    // 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::algo::ca
 
 
#endif  // CaMcPoint_h