CbmMvdAddress.cxx

Go to the documentation of this file.

/* Copyright (C) 2025 IKF Frankfurt University, Frankfurt am Main
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Ajit Kumar [committer], Jan Michel*/
 
#include "CbmMvdAddress.h"
 
#include "AlgoFairloggerCompat.h"  // for Logger, LOG
#include "CbmDefs.h"               // for kMvd
 
#include <iomanip>
#include <ios>
 
// ---- Bit shifts for the different levels ----
const int32_t CbmMvdAddress::fgkShift[] = {
  0,                         // system
  fgkShift[0] + fgkBits[0],  // station
  fgkShift[1] + fgkBits[1],  // side up/down
  fgkShift[2] + fgkBits[2],  // side left/right
  fgkShift[3] + fgkBits[3],  // side TB
  fgkShift[4] + fgkBits[4],  // ladder
  fgkShift[5] + fgkBits[5],  // sensor
  fgkShift[6] + fgkBits[6],  // sensor Y
  fgkShift[7] + fgkBits[7],  // sensor X
};
 
 
// ---- Bit masks for the different levels ----
const int32_t CbmMvdAddress::fgkMask[] = {
  (1 << fgkBits[0]) - 1,  // System (4 bits)
  (1 << fgkBits[1]) - 1,  // Station (2 bits)
  (1 << fgkBits[2]) - 1,  // SideUD (1 bit)
  (1 << fgkBits[3]) - 1,  // SideLR (1 bit)
  (1 << fgkBits[4]) - 1,  // SideTB (1 bit)
  (1 << fgkBits[5]) - 1,  // Ladder (2 bits)
  (1 << fgkBits[6]) - 1,  // Sensor (2 bits)
  (1 << fgkBits[7]) - 1,  // SensorY (9 bits)
  (1 << fgkBits[8]) - 1,  // SensorX (10 bits)
};
 
const int32_t CbmMvdAddress::fgkShiftSensorNr = fgkShift[kMvdStation];  // SensorNr starts at Station position
const int32_t CbmMvdAddress::fgkMaskSensorNr  = (1 << fgkBitsSensorNr) - 1;
 
// ---- Unique element address ---------------------------------
uint32_t CbmMvdAddress::GetAddress(int32_t station, int32_t sideUD, int32_t sideLR, int32_t sideTB, int32_t ladder,
                                   int32_t sensor, int32_t sensorY, int32_t sensorX)
{
  if (station >= (1 << fgkBits[kMvdStation])) {
    LOG(error) << "Station Id " << station << " exceeds maximum (" << (1 << fgkBits[kMvdStation]) - 1 << ")";
    return 0;
  }
  if (sideUD >= (1 << fgkBits[kMvdSideUD])) {
    LOG(error) << "SideUD Id " << sideUD << " exceeds maximum (" << (1 << fgkBits[kMvdSideUD]) - 1 << ")";
    return 0;
  }
  if (sideLR >= (1 << fgkBits[kMvdSideLR])) {
    LOG(error) << "SideLR Id " << sideLR << " exceeds maximum (" << (1 << fgkBits[kMvdSideLR]) - 1 << ")";
    return 0;
  }
  if (sideTB >= (1 << fgkBits[kMvdSideTB])) {
    LOG(error) << "SideTB Id " << sideTB << " exceeds maximum (" << (1 << fgkBits[kMvdSideTB]) - 1 << ")";
    return 0;
  }
  if (ladder >= (1 << fgkBits[kMvdLadder])) {
    LOG(error) << "Ladder Id " << ladder << " exceeds maximum (" << (1 << fgkBits[kMvdLadder]) - 1 << ")";
    return 0;
  }
  if (sensor >= (1 << fgkBits[kMvdSensor])) {
    LOG(error) << "Sensor Id " << sensor << " exceeds maximum (" << (1 << fgkBits[kMvdSensor]) - 1 << ")";
    return 0;
  }
  if (sensorY >= (1 << fgkBits[kMvdSensorY])) {
    LOG(error) << "SensorY " << sensorY << " exceeds maximum (" << (1 << fgkBits[kMvdSensorY]) - 1 << ")";
    return 0;
  }
  if (sensorX >= (1 << fgkBits[kMvdSensorX])) {
    LOG(error) << "SensorX " << sensorX << " exceeds maximum (" << (1 << fgkBits[kMvdSensorX]) - 1 << ")";
    return 0;
  }
 
  return ToIntegralType(ECbmModuleId::kMvd) << fgkShift[kMvdSystem] | station << fgkShift[kMvdStation]
         | sideUD << fgkShift[kMvdSideUD] | sideLR << fgkShift[kMvdSideLR] | sideTB << fgkShift[kMvdSideTB]
         | ladder << fgkShift[kMvdLadder] | sensor << fgkShift[kMvdSensor] | sensorY << fgkShift[kMvdSensorY]
         | sensorX << fgkShift[kMvdSensorX];
}
 
uint32_t CbmMvdAddress::GetAddress(int32_t* elementId)
{
  uint32_t address = ToIntegralType(ECbmModuleId::kMvd) << fgkShift[kMvdSystem];
  for (int32_t level = 1; level < kMvdNofLevels; level++) {
    if (elementId[level] >= (1 << fgkBits[level])) {
      LOG(error) << "Id " << elementId[level] << " for MVD level " << level << " exceeds maximum ("
                 << (1 << fgkBits[level]) - 1 << ")";
      return 0;
    }
    address |= elementId[level] << fgkShift[level];
  }
  return address;
}
 
uint32_t CbmMvdAddress::GetAddressFromSensorNrAndPixelXY(int32_t sensorNr, int32_t sensorY, int32_t sensorX)
{
  if (sensorNr >= (1 << fgkBitsSensorNr)) {
    LOG(fatal) << "Sensor Nr " << sensorNr << " exceeds maximum (" << (1 << fgkBits[fgkBitsSensorNr]) - 1 << ")";
    return 0;
  }
  if (sensorY >= (1 << fgkBits[kMvdSensorY])) {
    LOG(fatal) << "SensorY " << sensorY << " exceeds maximum (" << (1 << fgkBits[kMvdSensorY]) - 1 << ")";
    return 0;
  }
  if (sensorX >= (1 << fgkBits[kMvdSensorX])) {
    LOG(fatal) << "SensorX " << sensorX << " exceeds maximum (" << (1 << fgkBits[kMvdSensorX]) - 1 << ")";
    return 0;
  }
 
  return ToIntegralType(ECbmModuleId::kMvd) << fgkShift[kMvdSystem] | sensorNr << fgkShiftSensorNr
         | sensorY << fgkShift[kMvdSensorY] | sensorX << fgkShift[kMvdSensorX];
};
 
void CbmMvdAddress::Print()
{
  LOG(info) << "Number of MVD levels is " << kMvdNofLevels;
  for (int32_t level = 0; level < kMvdNofLevels; 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 CbmMvdAddress::SetElementId(uint32_t address, int32_t level, int32_t newId)
{
  if (level < 0 || level >= kMvdNofLevels) return address;
  if (newId >= (1 << fgkBits[level])) {
    LOG(error) << "Id " << newId << " for MVD level " << level << " exceeds maximum (" << (1 << fgkBits[level]) - 1
               << ")";
    return 0;
  }
  return (address & (~(fgkMask[level] << fgkShift[level]))) | (newId << fgkShift[level]);
}