detectors/trd/Hit.h

Go to the documentation of this file.

/* Copyright (C) 2024 Facility for Antiproton and Ion Research in Europe, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Dominik Smith [committer], Matus Kalisky, Florian Uhlig, Andrey Lebedev */
 
#pragma once
 
#include "CbmTrdAddress.h"  // for CbmTrdAddress
#include "Math/Rotation3D.h"
#include "Math/Vector3Dfwd.h"
 
#include <Rtypes.h>      // for CLRBIT, SETBIT, TESTBIT, ClassDef
#include <RtypesCore.h>  // for Double32_t
 
#include <boost/serialization/access.hpp>
 
#include <cstdint>
#include <string>  // for string
 
namespace cbm::algo::trd
{
 
  class Hit {
   public:
    enum HitDef
    {
      kType = 0  
        ,
      kMaxType  
        ,
      kRowCross  
        ,
      kOvfl  
    };
 
 
    Hit();
 
    Hit(int32_t address, const ROOT::Math::XYZVector& pos, const ROOT::Math::XYZVector& dpos, double dxy, int32_t refId,
        double eLoss, double time = 0., double timeError = 0.);
 
    Hit(int32_t address, double x, double y, double z, double dx, double dy, double dz, double dxy, int32_t refId,
        double time = -1., double timeError = -1.);
 
 
    ~Hit(){};
 
    /* Accessors */
    int32_t GetPlaneId() const { return CbmTrdAddress::GetLayerId(Address()); }
    double GetELoss() const { return fELoss; }
    bool GetClassType() const { return TESTBIT(fDefine, kType); }
    bool GetMaxType() const { return TESTBIT(fDefine, kMaxType); }
    bool HasOverFlow() const { return TESTBIT(fDefine, kOvfl); }
    bool IsRowCross() const { return TESTBIT(fDefine, kRowCross); }
    bool IsUsed() const { return (GetRefId() < 0); }
    double X() const { return fX; }
    double Y() const { return fY; }
    double Z() const { return fZ; }
    double Dx() const { return fDx; }
    double Dy() const { return fDy; }
    double Dz() const { return fDz; }
    double Dxy() const { return fDxy; }
    int32_t GetRefId() const { return fRefId; }
    int32_t Address() const { return fAddress; }
    double Time() const { return fTime; }
    double TimeError() const { return fTimeError; }
 
    void Position(ROOT::Math::XYZVector& pos) const;
 
    void PositionError(ROOT::Math::XYZVector& dpos) const;
 
    /* Setters */
    void SetELoss(double loss) { fELoss = loss; }
    void SetOverFlow(bool set = true) { set ? SETBIT(fDefine, kOvfl) : CLRBIT(fDefine, kOvfl); }
    void SetRowCross(bool set = true) { set ? SETBIT(fDefine, kRowCross) : CLRBIT(fDefine, kRowCross); }
    void SetClassType(bool set = true) { set ? SETBIT(fDefine, kType) : CLRBIT(fDefine, kType); }
    void SetMaxType(bool set = true) { set ? SETBIT(fDefine, kMaxType) : CLRBIT(fDefine, kMaxType); }
    void SetX(double x) { fX = x; }
    void SetY(double y) { fY = y; }
    void SetZ(double z) { fZ = z; }
    void SetDx(double dx) { fDx = dx; }
    void SetDy(double dy) { fDy = dy; }
    void SetDz(double dz) { fDz = dz; }
    void SetDxy(double dxy) { fDxy = dxy; }
    void SetRefId(int32_t refId) { fRefId = refId; }
    void SetAddress(int32_t address) { fAddress = address; }
    void SetTime(double time) { fTime = time; }
    void SetTime(double time, double error)
    {
      fTime      = time;
      fTimeError = error;
    }
    void SetTimeError(double error) { fTimeError = error; }
 
    void SetPosition(const ROOT::Math::XYZVector& pos);
 
    void SetPositionError(const ROOT::Math::XYZVector& dpos);
 
 
   private:
    double fX, fY, fZ;     
    double fDx, fDy, fDz;  
    double fDxy;           
    int32_t fRefId;        
    int32_t fAddress;      
    double fTime;          
    double fTimeError;     
 
    uint8_t fDefine;      // hit extra info
    int32_t fNeighborId;  // refId in case of row cross clusters
    Double32_t fELoss;    // Energy deposit due to TR + dEdx
 
   private:
    friend class boost::serialization::access;
 
    template<class Archive>
    void serialize(Archive& ar, unsigned int /*version*/)
    {
      ar& fX;
      ar& fY;
      ar& fZ;
      ar& fDx;
      ar& fDy;
      ar& fDz;
      ar& fDxy;
      ar& fRefId;
      ar& fAddress;
      ar& fTime;
      ar& fTimeError;
      ar& fDefine;
      ar& fNeighborId;
      ar& fELoss;
    }
  };
 
 
}  // namespace cbm::algo::trd