CbmTrdAddress.h

Go to the documentation of this file.

 
#ifndef CBMTRDDETECTORID_H
#define CBMTRDDETECTORID_H 1
 
#include "CbmDefs.h"     // for kTrd
#include <RtypesCore.h>  // for UInt_t, Int_t
#include <cassert>       // for assert
 
class CbmTrdAddress {
public:
  static UInt_t GetAddress(Int_t layerId,
                           Int_t moduleId,
                           Int_t sectorId,
                           Int_t rowId,
                           Int_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 UInt_t GetSystemId(UInt_t address) {
    return (address & (fgkSystemIdLength << fgkSystemIdShift))
           >> fgkSystemIdShift;
  }
 
  static UInt_t GetLayerId(UInt_t address) {
    return (address & (fgkLayerIdLength << fgkLayerIdShift)) >> fgkLayerIdShift;
  }
 
  static UInt_t GetModuleId(UInt_t address) {
    return (address & (fgkModuleIdLength << fgkModuleIdShift))
           >> fgkModuleIdShift;
  }
 
  static UInt_t GetSectorId(UInt_t address) {
    return (address & (fgkSectorIdLength << fgkSectorIdShift))
           >> fgkSectorIdShift;
  }
 
  static UInt_t GetRowId(UInt_t address) {
    return (address & (fgkRowIdLength << fgkRowIdShift)) >> fgkRowIdShift;
  }
 
  static UInt_t GetColumnId(UInt_t address) {
    return (address & (fgkColumnIdLength << fgkColumnIdShift))
           >> fgkColumnIdShift;
  }
 
  static UInt_t GetModuleAddress(UInt_t address) {
    return (address & (fgkModuleAddressLength << fgkModuleAddressStart))
           >> fgkModuleAddressStart;
  }
 
  static UInt_t GetSectorAddress(UInt_t address) {
    return (address & (fgkSectorAddressLength << fgkSectorAddressStart))
           >> fgkSectorAddressStart;
  }
 
  static UInt_t SetLayerId(UInt_t address, Int_t newLayerId) {
    assert(!(newLayerId < 0 || newLayerId > fgkLayerIdLength));
    return GetAddress(newLayerId,
                      GetModuleId(address),
                      GetSectorId(address),
                      GetRowId(address),
                      GetColumnId(address));
  }
 
  static UInt_t SetModuleId(UInt_t address, Int_t newModuleId) {
    assert(!(newModuleId < 0 || newModuleId > fgkModuleIdLength));
    return GetAddress(GetLayerId(address),
                      newModuleId,
                      GetSectorId(address),
                      GetRowId(address),
                      GetColumnId(address));
  }
 
  static UInt_t SetSectorId(UInt_t address, Int_t newSectorId) {
    assert(!(newSectorId < 0 || newSectorId > fgkSectorIdLength));
    return GetAddress(GetLayerId(address),
                      GetModuleId(address),
                      newSectorId,
                      GetRowId(address),
                      GetColumnId(address));
  }
 
  static UInt_t SetRowId(UInt_t address, Int_t newRowId) {
    assert(!(newRowId < 0 || newRowId > fgkRowIdLength));
    return GetAddress(GetLayerId(address),
                      GetModuleId(address),
                      GetSectorId(address),
                      newRowId,
                      GetColumnId(address));
  }
 
  static UInt_t SetColumnId(UInt_t address, Int_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 Int_t fgkSystemIdLength = 15;   // 2^4 - 1
  static const Int_t fgkLayerIdLength  = 15;   // 2^4 - 1
  static const Int_t fgkModuleIdLength = 127;  // 2^7 - 1
  static const Int_t fgkSectorIdLength = 3;    // 2^2 - 1
  static const Int_t fgkRowIdLength    = 127;  // 2^7 - 1
  static const Int_t fgkColumnIdLength = 255;  // 2^8 - 1
  // Number of a start bit for each volume
  static const Int_t fgkSystemIdShift = 0;
  static const Int_t fgkLayerIdShift  = 4;
  static const Int_t fgkModuleIdShift = 8;
  static const Int_t fgkSectorIdShift = 15;
  static const Int_t fgkRowIdShift    = 17;
  static const Int_t fgkColumnIdShift = 24;
  // Start bit and length for unique module address.
  // For unique module address use all bits up to sector ID.
  static const Int_t fgkModuleAddressStart  = 0;
  static const Int_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 Int_t fgkSectorAddressStart  = 0;
  static const Int_t fgkSectorAddressLength = 131071;  // 2^17 - 1
};
 
#endif