CbmTofAddress.h

Go to the documentation of this file.

/* Copyright (C) 2013-2025 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pierre-Alain Loizeau, Florian Uhlig [committer], Norbert Herrmann, Sergei Zharko */


 
#ifndef CBMTOFADDRESS_H
#define CBMTOFADDRESS_H 1
 
#include "CbmAddress.h"             // for CbmAddress, CbmAddress::fgkSystem...
#include "CbmDefs.h"                // for kTof
#include "CbmTofDetectorId.h"       // for CbmTofDetectorInfo
#include "CbmTofDetectorId_v12b.h"  // for CbmTofDetectorId_v12b
 
#include <cstdint>
#include <string>
 
class CbmTofAddress : public CbmAddress {
 public:
  CbmTofAddress(){};

  virtual ~CbmTofAddress(){};

  static int32_t GetSystemIdBitmask() { return fgkSystemIdBitmask; }
  static int32_t GetSmIdBitmask() { return fgkSmIdBitmask; }
  static int32_t GetSmTypeBitmask() { return fgkSmTypeBitmask; }
  static int32_t GetRpcIdBitmask() { return fgkRpcIdBitmask; }
  static int32_t GetChannelSideBitmask() { return fgkChannelSideBitmask; }
  static int32_t GetChannelIdBitmask() { return fgkChannelIdBitmask; }
  static int32_t GetRpcTypeBitmask() { return fgkRpcTypeBitmask; }
 

  static int32_t GetNofSmIdBits() { return fgkSmIdBits; };
  static int32_t GetNofSmTypeBits() { return fgkSmTypeBits; };
  static int32_t GetNofRpcIdBits() { return fgkRpcIdBits; };
  static int32_t GetNofChannelIdBits() { return fgkChannelIdBits; };
  static int32_t GetNofChSideBits() { return fgkChannelSideBits; };
 

  static int32_t GetSmIdOffset() { return fgkSmIdOffset; }
  static int32_t GetSmTypeOffset() { return fgkSmTypeOffset; }
  static int32_t GetRpcIdOffset() { return fgkRpcIdOffset; }
  static int32_t GetChannelSideOffset() { return fgkChannelSideOffset; }
  static int32_t GetChannelIdOffset() { return fgkChannelIdOffset; }
  static int32_t GetRpcTypeOffset() { return fgkRpcTypeOffset; }
  static uint32_t GetDetectorId(uint32_t address) { return GetRpcFullId(address); }
 

  static int32_t GetSmId(uint32_t address) { return ((address >> fgkSmIdOffset) & ((1 << fgkSmIdBits) - 1)); };
  static int32_t GetSmType(uint32_t address) { return ((address >> fgkSmTypeOffset) & ((1 << fgkSmTypeBits) - 1)); };
  static int32_t GetRpcId(uint32_t address) { return ((address >> fgkRpcIdOffset) & ((1 << fgkRpcIdBits) - 1)); };
  static int32_t GetRpcType(uint32_t address) { return ((address >> fgkRpcTypeOffset) & ((1 << fgkRpcTypeBits) - 1)); };
  static int32_t GetChannelId(uint32_t address)
  {
    return ((address >> fgkChannelIdOffset) & ((1 << fgkChannelIdBits) - 1));
  };

  static int32_t GetChannelSide(uint32_t address)
  {
    return ((address >> fgkChannelSideOffset) & ((1 << fgkChannelSideBits) - 1));
  };

  static int32_t GetModFullId(uint32_t address) { return (address & fgkiModFullIdMask); };
  static int32_t GetRpcFullId(uint32_t address) { return (address & fgkiRpcFullIdMask); };
  static int32_t GetStripFullId(uint32_t address) { return (address & fgkiStripFullIdMask); };

  static uint32_t GetUniqueAddress(uint32_t Sm, uint32_t Rpc, uint32_t Channel, uint32_t Side = 0, uint32_t SmType = 0,
                                   uint32_t RpcType = 0)
  {
    return (uint32_t)(((ToIntegralType(ECbmModuleId::kTof) & ((1 << fgkSystemBits) - 1)))
                      + ((Sm & ((1 << fgkSmIdBits) - 1)) << fgkSmIdOffset)
                      + ((SmType & ((1 << fgkSmTypeBits) - 1)) << fgkSmTypeOffset)
                      + ((Side & ((1 << fgkChannelSideBits) - 1)) << fgkChannelSideOffset)
                      + ((Rpc & ((1 << fgkRpcIdBits) - 1)) << fgkRpcIdOffset)
                      + ((Channel & ((1 << fgkChannelIdBits) - 1)) << fgkChannelIdOffset)
                      + ((RpcType & ((1 << fgkRpcTypeBits) - 1)) << fgkRpcTypeOffset));
  };
 
  static bool SameModule(uint32_t addressA, uint32_t addressB)
  {
    return (GetModFullId(addressA) == GetModFullId(addressB)) ? true : false;
  };

  static uint32_t ConvertCbmTofDetectorInfo(CbmTofDetectorInfo infoInput)
  {
    // For now assume that the system ID will always be correct
    // Otherwise would need including CbmDetectorList.h
    //   if( kTof != infoInput.fDetectorSystem)
    //      return 0;
 
    return GetUniqueAddress(infoInput.fSModule, infoInput.fCounter, infoInput.fCell, 0, infoInput.fSMtype,
                            infoInput.fCounterType);
  };
  static uint32_t ConvertCbmTofDetectorId(int32_t detIdInput)
  {
    // For now assume that the system ID will always be correct
    // Otherwise would need including CbmDetectorList.h
    //         if( kTof != CbmTofDetectorId::GetSystemId( detIdInput ) )
    //            return 0;
    CbmTofDetectorId_v12b detId;
    return GetUniqueAddress(detId.GetSModule(detIdInput), detId.GetCounter(detIdInput), detId.GetCell(detIdInput), 0,
                            detId.GetSMType(detIdInput));
  };

  static std::string ToString(int32_t address);
 
 private:
  // FIXME: SZh 7.2.2025: Make these fields constexpr

 
  // v14a
  /*
  // Number of bits for Super Module Id in the address field
  static const int32_t fgkSmIdBits = 8;
  // Number of bits for Super Module Type in the address field
  static const int32_t fgkSmTypeBits = 4;
  // Number of bits for Rpc Id in the address field
  static const int32_t fgkRpcIdBits = 7;
  // Number of bits for Channel Side in the address field
  static const int32_t fgkChannelSideBits = 1;
  // Number of bits for Channel Id in the address field
  static const int32_t fgkChannelIdBits = 8;
  // Number of bits for Rpc Type in the address field
  static const int32_t fgkRpcTypeBits = 0;
  */
  // v21a
  // Number of bits for Super Module Id in the address field
  static const int32_t fgkSmIdBits = 7;
  // Number of bits for Super Module Type in the address field
  static const int32_t fgkSmTypeBits = 4;
  // Number of bits for Rpc Id in the address field
  static const int32_t fgkRpcIdBits = 6;
  // Number of bits for Channel Side in the address field
  static const int32_t fgkChannelSideBits = 1;
  // Number of bits for Channel Id in the address field
  static const int32_t fgkChannelIdBits = 6;
  // Number of bits for Rpc Type in the address field
  static const int32_t fgkRpcTypeBits = 4;

  static const int32_t fgkSmIdOffset;
  static const int32_t fgkSmTypeOffset;
  static const int32_t fgkChannelSideOffset;
  static const int32_t fgkRpcIdOffset;
  static const int32_t fgkChannelIdOffset;
  static const int32_t fgkRpcTypeOffset;

  static const int32_t fgkiModFullIdMask;

  static const int32_t fgkiRpcFullIdMask;

  static const int32_t fgkiStripFullIdMask;
 

  static const int32_t fgkSystemIdBitmask;     //<  A bitmask for System ID
  static const int32_t fgkSmIdBitmask;         //<  A bitmask for SM
  static const int32_t fgkSmTypeBitmask;       //<  A bitmask for SM Type
  static const int32_t fgkRpcIdBitmask;        //<  A bitmask for RPC ID
  static const int32_t fgkChannelSideBitmask;  //<  A bitmask for Channel Side
  static const int32_t fgkChannelIdBitmask;    //<  A bitmask for Channel ID
  static const int32_t fgkRpcTypeBitmask;      //<  A bitmask for RPC Type
};
 
#endif  // CBMTOFADDRESS_H