CbmStsAddress.h

Go to the documentation of this file.

/* Copyright (C) 2013-2020 GSI/JINR-LIT, Darmstadt/Dubna
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Volker Friese, Andrey Lebedev [committer] */
 
#ifndef CBMSTSADDRESS_H
#define CBMSTSADDRESS_H 1
 
#include "AlgoFairloggerCompat.h"
#include "CbmDefs.h"  // for ECbmModuleId
 
#include <cassert>  // for assert
#include <cstdint>  // for uint32_t
#include <sstream>  // for string
 
#include <xpu/defines.h>  // for XPU_D
 
enum EStsElementLevel
{
  kStsSystem,
  kStsUnit,
  kStsLadder,
  kStsHalfLadder,
  kStsModule,
  kStsSensor,
  kStsSide,
  kStsNofLevels
};
 
 
namespace CbmStsAddress
{
 
  inline constexpr uint32_t kCurrentVersion = 1;
 
  // --- These values are not to be changed if backward compatibility
  // --- shall be maintained.
  inline constexpr int32_t kVersionSize  = 4;   // Bits for version number
  inline constexpr int32_t kVersionShift = 28;  // First bit for version number
  inline constexpr int32_t kVersionMask  = (1 << kVersionSize) - 1;
 
  namespace Detail
  {
    // clang-format off
    // -----    Definition of address bit field   ------------------------------
    inline constexpr uint16_t kBits[kCurrentVersion + 1][kStsNofLevels] = {
 
      // Version 0 (until 23 August 2017)
      {
        4,  // system
        4,  // unit / station
        4,  // ladder
        1,  // half-ladder
        3,  // module
        2,  // sensor
        1   // side
      },
 
      // Version 1 (current, since 23 August 2017)
      {
        4,  // system
        6,  // unit
        5,  // ladder
        1,  // half-ladder
        5,  // module
        4,  // sensor
        1   // side
      }
 
    };
    // -------------------------------------------------------------------------
 
    // -----    Bit shifts -----------------------------------------------------
    inline constexpr int32_t kShift[kCurrentVersion + 1][kStsNofLevels] = {
      {0, kShift[0][0] + kBits[0][0], kShift[0][1] + kBits[0][1], kShift[0][2] + kBits[0][2], kShift[0][3] + kBits[0][3],
      kShift[0][4] + kBits[0][4], kShift[0][5] + kBits[0][5]},
 
      {0, kShift[1][0] + kBits[1][0], kShift[1][1] + kBits[1][1], kShift[1][2] + kBits[1][2], kShift[1][3] + kBits[1][3],
      kShift[1][4] + kBits[1][4], kShift[1][5] + kBits[1][5]}};
    // -------------------------------------------------------------------------
 
    // -----    Bit masks  -----------------------------------------------------
    inline constexpr int32_t kMask[kCurrentVersion + 1][kStsNofLevels] = {
      {(1 << kBits[0][0]) - 1, (1 << kBits[0][1]) - 1, (1 << kBits[0][2]) - 1, (1 << kBits[0][3]) - 1,
      (1 << kBits[0][4]) - 1, (1 << kBits[0][5]) - 1, (1 << kBits[0][6]) - 1},
 
      {(1 << kBits[1][0]) - 1, (1 << kBits[1][1]) - 1, (1 << kBits[1][2]) - 1, (1 << kBits[1][3]) - 1,
      (1 << kBits[1][4]) - 1, (1 << kBits[1][5]) - 1, (1 << kBits[1][6]) - 1}};
    // -------------------------------------------------------------------------
    // clang-format on
  }  // Namespace Detail
 
 
  int32_t GetAddress(uint32_t unit = 0, uint32_t ladder = 0, uint32_t halfladder = 0, uint32_t module = 0,
                     uint32_t sensor = 0, uint32_t side = 0, uint32_t version = kCurrentVersion);
 
 
  int32_t GetAddress(uint32_t* elementId, uint32_t version);
 
 
  int32_t GetMotherAddress(int32_t address, int32_t level);
 
 
  uint32_t GetElementId(int32_t address, int32_t level);
 
 
  ECbmModuleId GetSystemId(int32_t address);
 
 
  uint32_t GetVersion(int32_t address);
 
 
  int32_t SetElementId(int32_t address, int32_t level, uint32_t newId);
 
  XPU_D inline int32_t UnpackDigiAddress(int32_t digiAddress)
  {
    using namespace Detail;
    return digiAddress << kShift[1][kStsUnit] | ToIntegralType(ECbmModuleId::kSts) << kShift[1][kStsSystem]
           | 1u << kVersionShift;
  }
 
  XPU_D inline int32_t PackDigiAddress(int32_t address)
  {
    using namespace Detail;
    constexpr int32_t kDMask = kMask[1][kStsUnit] << kShift[1][kStsUnit] | kMask[1][kStsLadder] << kShift[1][kStsLadder]
                               | kMask[1][kStsHalfLadder] << kShift[1][kStsHalfLadder]
                               | kMask[1][kStsModule] << kShift[1][kStsModule];
 
    int32_t ret = (address & kDMask) >> kShift[1][kStsUnit];
 
#if XPU_IS_CPU
    // Check that no bits were set, that are stripped by this function.
    if (address != UnpackDigiAddress(ret)) {
      LOG(error) << "Address " << address << " contains bits that are stripped by PackDigiAddress";
    }
#endif
    assert(address == UnpackDigiAddress(ret));
 
    return ret;
  }
 
  std::string ToString(int32_t address);
 
}  // Namespace CbmStsAddress
 
 
#endif  // CBMSTSADDRESS_H