CbmTrackingDetectorInterfaceBase.h

Go to the documentation of this file.

/* Copyright (C) 2022-2024 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergey Gorbunov, Sergei Zharko [committer] */
 
/***************************************************************************************************
 * @file   CbmTrackingDetectorInterfaceBase.h
 * @brief  Base abstract class for tracking detector interface to L1
 * @since  31.05.2022
 * @author S.Zharko <s.zharko@gsi.de>
 ***************************************************************************************************/
 
#ifndef CbmTrackingDetectorInterfaceBase_h
#define CbmTrackingDetectorInterfaceBase_h 1
 
#include "CbmHit.h"
#include "CbmPixelHit.h"
#include "FairMCPoint.h"
 
#include <array>
#include <cmath>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
 
class TGeoNode;
class TString;
 
class CbmTrackingDetectorInterfaceBase {
 public:
  struct VolumeInfo {
    double fXmin{+std::numeric_limits<double>::max()};  
    double fXmax{-std::numeric_limits<double>::max()};  
    double fYmin{+std::numeric_limits<double>::max()};  
    double fYmax{-std::numeric_limits<double>::max()};  
    double fZmin{+std::numeric_limits<double>::max()};  
    double fZmax{-std::numeric_limits<double>::max()};  
 
    VolumeInfo(double xMin, double xMax, double yMin, double yMax, double zMin, double zMax)
      : fXmin(xMin)
      , fXmax(xMax)
      , fYmin(yMin)
      , fYmax(yMax)
      , fZmin(zMin)
      , fZmax(zMax)
    {
    }
 
    VolumeInfo() = default;
    //VolumeInfo(const VolumeInfo&) = default;
    //VolumeInfo(VolumeInfo&&) = default;
    //VolumeInfo& operator=(const VolumeInfo&) = default;
    //VolumeInfo& operator=(VolumeInfo&&) = default;
 
    VolumeInfo& operator+=(const VolumeInfo& other)
    {
      fXmin = std::min(fXmin, other.fXmin);
      fXmax = std::max(fXmax, other.fXmax);
      fYmin = std::min(fYmin, other.fYmin);
      fYmax = std::max(fYmax, other.fYmax);
      fZmin = std::min(fZmin, other.fZmin);
      fZmax = std::max(fZmax, other.fZmax);
      return *this;
    }
 
    std::string ToString() const;
  };
 
 public:
  virtual ~CbmTrackingDetectorInterfaceBase() {}
 
  bool Check() const;
 
  virtual std::string GetDetectorName() const = 0;
 
  int GetNtrackingStations() const { return fvStationFullVolume.size(); }
 
  virtual std::tuple<double, double> GetStereoAnglesSensor(int address) const = 0;
 
  virtual int GetTrackingStationIndex(const CbmHit* hit) const = 0;
 
  virtual int GetTrackingStationIndex(const FairMCPoint* point) const = 0;
 
  virtual int GetTrackingStationIndex(int address) const = 0;
 
  double GetXmax(int stationId) const { return fvStationFullVolume[stationId].fXmax; }
 
  double GetXmin(int stationId) const { return fvStationFullVolume[stationId].fXmin; }
 
  double GetYmax(int stationId) const { return fvStationFullVolume[stationId].fYmax; }
 
  double GetYmin(int stationId) const { return fvStationFullVolume[stationId].fYmin; }
 
  double GetZref(int stationId) const { return 0.5 * (GetActiveZmin(stationId) + GetActiveZmax(stationId)); }
 
  virtual double GetZrefModule(int address) { return GetZref(GetTrackingStationIndex(address)); }
 
  double GetZmin(int stationId) const { return fvStationFullVolume[stationId].fZmin; }
 
  double GetZmax(int stationId) const { return fvStationFullVolume[stationId].fZmax; }
 
  double GetActiveXmin(int stationId) const { return fvStationActiveVolume[stationId].fXmin; }
 
  double GetActiveXmax(int stationId) const { return fvStationActiveVolume[stationId].fXmax; }
 
  double GetActiveYmin(int stationId) const { return fvStationActiveVolume[stationId].fYmin; }
 
  double GetActiveYmax(int stationId) const { return fvStationActiveVolume[stationId].fYmax; }
 
  double GetActiveZmin(int stationId) const { return fvStationActiveVolume[stationId].fZmin; }
 
  double GetActiveZmax(int stationId) const { return fvStationActiveVolume[stationId].fZmax; }
 
  virtual bool IsTimeInfoProvided(int stationId) const = 0;
 
  virtual std::tuple<double, double, double> GetHitRanges(const CbmPixelHit& hit) const
  {
    // by default assume gaussian distributions of errors
    return std::tuple(3.5 * hit.GetDx(), 3.5 * hit.GetDy(), 3.5 * hit.GetTimeError());
  }
 
  static constexpr bool kUseDynamicCast{true};
 
  std::string ToString() const;
 
 protected:
  static constexpr bool kLegacy{false};
 
  std::vector<TString> CollectNodes(const TString& detector, const TString& component, const TString& path,
                                    TGeoNode* pNode);
 
  VolumeInfo ReadVolume(const TString& path);
 
  // NOTE: SZh 10.09.2024: For now the passive and active volumes destinguish in TRD and TOF only. For STS
  //                       the z-components are active, and the x- and y-components are passive. For
  //                       MVD and MuCh the components are legacy (active? taken from digitizers).
  std::vector<VolumeInfo> fvStationFullVolume{};    
  std::vector<VolumeInfo> fvStationActiveVolume{};  
};
 
#endif  // CbmTrackingDetectorInterfaceBase_h