CbmTrdAddress.h

Go to the documentation of this file.

/* Copyright (C) 2009-2020 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Andrey Lebedev, Florian Uhlig [committer] */
 
#ifndef CBMTRDDETECTORID_H
#define CBMTRDDETECTORID_H 1
 
#include "CbmDefs.h"  // for kTrd
 
#include <cassert>  // for assert
#include <cstdint>
 
 
class CbmTrdAddress {
public:
  static uint32_t GetAddress(int32_t layerId, int32_t moduleId, int32_t sectorId, int32_t rowId, int32_t columnId)
  {
    assert(!(layerId < 0 || layerId > fgkLayerIdLength || moduleId < 0 || moduleId > fgkModuleIdLength || sectorId < 0
             || sectorId > fgkSectorIdLength || rowId < 0 || rowId > fgkRowIdLength || columnId < 0
             || columnId > fgkColumnIdLength));
    return (ToIntegralType(ECbmModuleId::kTrd) << fgkSystemIdShift) | (layerId << fgkLayerIdShift)
           | (moduleId << fgkModuleIdShift) | (sectorId << fgkSectorIdShift) | (rowId << fgkRowIdShift)
           | (columnId << fgkColumnIdShift);
  }
 
  static uint32_t GetSystemId(uint32_t address)
  {
    return (address & (fgkSystemIdLength << fgkSystemIdShift)) >> fgkSystemIdShift;
  }
 
  static uint32_t GetLayerId(uint32_t address)
  {
    return (address & (fgkLayerIdLength << fgkLayerIdShift)) >> fgkLayerIdShift;
  }
 
  static uint32_t GetModuleId(uint32_t address)
  {
    return (address & (fgkModuleIdLength << fgkModuleIdShift)) >> fgkModuleIdShift;
  }
 
  static uint32_t GetSectorId(uint32_t address)
  {
    return (address & (fgkSectorIdLength << fgkSectorIdShift)) >> fgkSectorIdShift;
  }
 
  static uint32_t GetRowId(uint32_t address) { return (address & (fgkRowIdLength << fgkRowIdShift)) >> fgkRowIdShift; }
 
  static uint32_t GetColumnId(uint32_t address)
  {
    return (address & (fgkColumnIdLength << fgkColumnIdShift)) >> fgkColumnIdShift;
  }
 
  static uint32_t GetModuleAddress(uint32_t address)
  {
    return (address & (fgkModuleAddressLength << fgkModuleAddressStart)) >> fgkModuleAddressStart;
  }
 
  static uint32_t GetSectorAddress(uint32_t address)
  {
    return (address & (fgkSectorAddressLength << fgkSectorAddressStart)) >> fgkSectorAddressStart;
  }
 
  static uint32_t SetLayerId(uint32_t address, int32_t newLayerId)
  {
    assert(!(newLayerId < 0 || newLayerId > fgkLayerIdLength));
    return GetAddress(newLayerId, GetModuleId(address), GetSectorId(address), GetRowId(address), GetColumnId(address));
  }
 
  static uint32_t SetModuleId(uint32_t address, int32_t newModuleId)
  {
    assert(!(newModuleId < 0 || newModuleId > fgkModuleIdLength));
    return GetAddress(GetLayerId(address), newModuleId, GetSectorId(address), GetRowId(address), GetColumnId(address));
  }
 
  static uint32_t SetSectorId(uint32_t address, int32_t newSectorId)
  {
    assert(!(newSectorId < 0 || newSectorId > fgkSectorIdLength));
    return GetAddress(GetLayerId(address), GetModuleId(address), newSectorId, GetRowId(address), GetColumnId(address));
  }
 
  static uint32_t SetRowId(uint32_t address, int32_t newRowId)
  {
    assert(!(newRowId < 0 || newRowId > fgkRowIdLength));
    return GetAddress(GetLayerId(address), GetModuleId(address), GetSectorId(address), newRowId, GetColumnId(address));
  }
 
  static uint32_t SetColumnId(uint32_t address, int32_t newColumnId)
  {
    assert(!(newColumnId < 0 || newColumnId > fgkColumnIdLength));
    return GetAddress(GetLayerId(address), GetModuleId(address), GetSectorId(address), GetRowId(address), newColumnId);
  }
 
private:
  // Length of the index of the corresponding volume
  static const int32_t fgkSystemIdLength = 15;   // 2^4 - 1
  static const int32_t fgkLayerIdLength  = 15;   // 2^4 - 1
  static const int32_t fgkModuleIdLength = 127;  // 2^7 - 1
  static const int32_t fgkSectorIdLength = 3;    // 2^2 - 1
  static const int32_t fgkRowIdLength    = 127;  // 2^7 - 1
  static const int32_t fgkColumnIdLength = 255;  // 2^8 - 1
  // Number of a start bit for each volume
  static const int32_t fgkSystemIdShift = 0;
  static const int32_t fgkLayerIdShift  = 4;
  static const int32_t fgkModuleIdShift = 8;
  static const int32_t fgkSectorIdShift = 15;
  static const int32_t fgkRowIdShift    = 17;
  static const int32_t fgkColumnIdShift = 24;
  // Start bit and length for unique module address.
  // For unique module address use all bits up to sector ID.
  static const int32_t fgkModuleAddressStart  = 0;
  static const int32_t fgkModuleAddressLength = 32767;  // 2^15 - 1
  // Start bit and length for unique sector address.
  // For unique sector address use all bits up to column ID.
  static const int32_t fgkSectorAddressStart  = 0;
  static const int32_t fgkSectorAddressLength = 131071;  // 2^17 - 1
};
 
#endif