CbmMustAddress.cxx

Go to the documentation of this file.

/* Copyright (C) 2025 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Radoslaw Karabowicz [committer] */
 
#include "CbmMustAddress.h"
 
#include "AlgoFairloggerCompat.h"  // for Logger, LOG
#include "CbmDefs.h"               // for kMust
 
#include <iomanip>  // for setw, __iom_t6
#include <ios>      // for right
 
 
// -----    Definition of the address field   -------------------------------
const int32_t CbmMustAddress::fgkBits[] = {fgkSystemBits,  // system = kMUST
                                           4,              // station
                                           4,              // layer
                                           8,              // module
                                           10};            // tube
// -------------------------------------------------------------------------
 
// -----    Initialisation of bit shifts -----------------------------------
const int32_t CbmMustAddress::fgkShift[] = {
  0, CbmMustAddress::fgkShift[0] + CbmMustAddress::fgkBits[0], CbmMustAddress::fgkShift[1] + CbmMustAddress::fgkBits[1],
  CbmMustAddress::fgkShift[2] + CbmMustAddress::fgkBits[2], CbmMustAddress::fgkShift[3] + CbmMustAddress::fgkBits[3]};
// -------------------------------------------------------------------------
 
 
// -----    Initialisation of bit masks  -----------------------------------
const int32_t CbmMustAddress::fgkMask[] = {(1 << fgkBits[0]) - 1, (1 << fgkBits[1]) - 1, (1 << fgkBits[2]) - 1,
                                           (1 << fgkBits[3]) - 1, (1 << fgkBits[4]) - 1};
// -------------------------------------------------------------------------
 
 
// -----  Unique element address   -----------------------------------------
uint32_t CbmMustAddress::GetAddress(int32_t station, int32_t layer, int32_t module, int32_t tube)
{
 
  // Catch overrunning of allowed ranges
  if (station >= (1 << fgkBits[kMustStation])) {
    LOG(error) << "Station Id " << station << " exceeds maximum (" << (1 << fgkBits[kMustStation]) - 1 << ")";
    return 0;
  }
  if (layer >= (1 << fgkBits[kMustLayer])) {
    LOG(error) << "Layer Id " << layer << " exceeds maximum (" << (1 << fgkBits[kMustLayer]) - 1 << ")";
    return 0;
  }
  if (module >= (1 << fgkBits[kMustModule])) {
    LOG(error) << "Module Id " << module << " exceeds maximum (" << (1 << fgkBits[kMustModule]) - 1 << ")";
    return 0;
  }
  if (tube >= (1 << fgkBits[kMustTube])) {
    LOG(error) << "Tube Id " << tube << " exceeds maximum (" << (1 << fgkBits[kMustTube]) - 1 << ")";
    return 0;
  }
 
  return ToIntegralType(ECbmModuleId::kMust) << fgkShift[kMustSystem] | station << fgkShift[kMustStation]
         | layer << fgkShift[kMustLayer] | module << fgkShift[kMustModule] | tube << fgkShift[kMustTube];
}
// -------------------------------------------------------------------------
 
 
// -----  Unique element address   -----------------------------------------
uint32_t CbmMustAddress::GetAddress(int32_t* elementId)
{
 
  uint32_t address = ToIntegralType(ECbmModuleId::kMust) << fgkShift[kMustSystem];
  for (int32_t level = 1; level < kMustNofLevels; level++) {
    if (elementId[level] >= (1 << fgkBits[level])) {
      LOG(error) << "Id " << elementId[level] << " for MuST level " << level << " exceeds maximum ("
                 << (1 << fgkBits[level]) - 1 << ")";
      return 0;
    }
    address = address | (elementId[level] << fgkShift[level]);
  }
 
  return address;
}
// -------------------------------------------------------------------------
 
 
// -----   Print info   ----------------------------------------------------
void CbmMustAddress::Print()
{
  LOG(info) << "Number of MuST levels is " << kMustNofLevels;
  for (int32_t level = 0; level < kMustNofLevels; level++)
    LOG(info) << "Level " << std::setw(2) << std::right << level << ": bits " << std::setw(2) << fgkBits[level]
              << ", max. range " << std::setw(6) << fgkMask[level];
}
// -------------------------------------------------------------------------
 
 
// -------------------------------------------------------------------------
uint32_t CbmMustAddress::SetElementId(uint32_t address, int32_t level, int32_t newId)
{
  if (level < 0 || level >= kMustNofLevels) return address;
  if (newId >= (1 << fgkBits[level])) {
    LOG(error) << "Id " << newId << " for MuST level " << level << " exceeds maximum (" << (1 << fgkBits[level]) - 1
               << ")";
    return 0;
  }
  return (address & (~(fgkMask[level] << fgkShift[level]))) | (newId << fgkShift[level]);
}
// -------------------------------------------------------------------------
 
#ifndef NO_ROOT
ClassImp(CbmMustAddress)
#endif