CaHit.h

Go to the documentation of this file.

/* Copyright (C) 2007-2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Valentina Akishina, Igor Kulakov, Sergey Gorbunov [committer], Maksym Zyzak */
 
 
#pragma once  // include this header only once per compilation unit
 
#include "CaSimd.h"
 
#include <boost/serialization/access.hpp>
 
#include <string>
 
namespace cbm::algo::ca
{
  struct CaHitTimeInfo {
    fscal fEventTimeMin{-std::numeric_limits<fscal>::max() / 2.};
    fscal fEventTimeMax{std::numeric_limits<fscal>::max() / 2.};
    fscal fMaxTimeBeforeHit{0.};  //< max event time for hits [0 .. hit] in the station hit array
    fscal fMinTimeAfterHit{0.};   //< min event time for hits [hit ... ] in the station hit array
  };
 
  // FIXME: Move typedefs to another header (potential problems with dependencies)
  using HitIndex_t    = unsigned int;  
  using HitKeyIndex_t = unsigned int;  
 
  class Hit {
    friend class boost::serialization::access;
 
   public:
    Hit() = default;
 
    bool Check() const;
 
 
    void SetFrontKey(HitKeyIndex_t key) { fFrontKey = key; }
 
    void SetBackKey(HitKeyIndex_t key) { fBackKey = key; }
 
    void SetX(fscal x) { fX = x; }
 
    void SetY(fscal y) { fY = y; }
 
    void SetZ(fscal z) { fZ = z; }
 
    void SetT(fscal t) { fT = t; }
 
    void SetDx2(fscal dx2) { fDx2 = dx2; }
 
    void SetDy2(fscal dy2) { fDy2 = dy2; }
 
    void SetDxy(fscal dxy) { fDxy = dxy; }
 
    void SetDt2(fscal dt2) { fDt2 = dt2; }
 
    void SetRangeX(fscal rangeX) { fRangeX = rangeX; }
 
    void SetRangeY(fscal rangeY) { fRangeY = rangeY; }
 
    void SetRangeT(fscal rangeT) { fRangeT = rangeT; }
 
    void SetId(HitIndex_t id) { fId = id; }
 
    void SetStation(int station) { fStation = station; }
 
 
    HitKeyIndex_t FrontKey() const { return fFrontKey; }
 
    HitKeyIndex_t BackKey() const { return fBackKey; }
 
    fscal X() const { return fX; }
 
    fscal Y() const { return fY; }
 
    fscal Z() const { return fZ; }
 
    fscal T() const { return fT; }
 
    fscal dX2() const { return fDx2; }
 
    fscal dY2() const { return fDy2; }
 
    fscal dXY() const { return fDxy; }
 
    fscal dT2() const { return fDt2; }
 
    fscal RangeX() const { return fRangeX; }
 
    fscal RangeY() const { return fRangeY; }
 
    fscal RangeT() const { return fRangeT; }
 
    HitIndex_t Id() const { return fId; }
 
    int Station() const { return fStation; }
 
    std::string ToString() const;
 
    std::string ToString(int verbose, bool bHeader) const;
 
   private:
 
 
    HitKeyIndex_t fFrontKey{0};  
    HitKeyIndex_t fBackKey{0};   
 
    fscal fX{0.};       
    fscal fY{0.};       
    fscal fZ{0.};       
    fscal fT{0.};       
    fscal fDx2{0.};     
    fscal fDy2{0.};     
    fscal fDxy{0.};     
    fscal fDt2{0.};     
    fscal fRangeX{0.};  
    fscal fRangeY{0.};  
    fscal fRangeT{0.};  
 
    HitIndex_t fId{0};  
    int fStation{-1};   
 
   private:
    template<class Archive>
    void serialize(Archive& ar, const unsigned int /*version*/)
    {
      ar& fFrontKey;
      ar& fBackKey;
      ar& fX;
      ar& fY;
      ar& fZ;
      ar& fT;
      ar& fDx2;
      ar& fDy2;
      ar& fDxy;
      ar& fDt2;
      ar& fRangeX;
      ar& fRangeY;
      ar& fRangeT;
      ar& fId;
      ar& fStation;
    }
  };
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  inline bool Hit::Check() const
  {
    bool res = true;
    res &= std::isfinite(fX);
    res &= std::isfinite(fY);
    res &= std::isfinite(fZ);
    res &= std::isfinite(fT);
    res &= std::isfinite(fDx2);
    res &= std::isfinite(fDy2);
    res &= std::isfinite(fDxy);
    res &= std::isfinite(fDt2);
    res &= (fDx2 || fDy2 || fDxy || fDt2);  // TODO: research
    res &= (fT < 1.e+9);
    return res;
  }
 
}  // namespace cbm::algo::ca