diff --git a/core/data/sts/CbmStsAddress.cxx b/core/data/sts/CbmStsAddress.cxx
index a7e55fb61077f1dbf548f511baa8e41a8899260f..81fb9c7959790c8937fc625f72bad6cd735765a1 100644
--- a/core/data/sts/CbmStsAddress.cxx
+++ b/core/data/sts/CbmStsAddress.cxx
@@ -20,7 +20,7 @@ namespace CbmStsAddress
{
// ----- Definition of address bit field ------------------------------
- const UShort_t kBits[kCurrentVersion + 1][kStsNofLevels] = {
+ const uint16_t kBits[kCurrentVersion + 1][kStsNofLevels] = {
// Version 0 (until 23 August 2017)
{
@@ -49,7 +49,7 @@ namespace CbmStsAddress
// ----- Bit shifts -----------------------------------------------------
- const Int_t kShift[kCurrentVersion + 1][kStsNofLevels] = {
+ const 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]},
@@ -59,7 +59,7 @@ namespace CbmStsAddress
// ----- Bit masks -----------------------------------------------------
- const Int_t kMask[kCurrentVersion + 1][kStsNofLevels] = {
+ const 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},
@@ -72,39 +72,39 @@ namespace CbmStsAddress
// ----- Construct address from element Ids ------------------------------
-Int_t CbmStsAddress::GetAddress(UInt_t unit, UInt_t ladder, UInt_t halfladder, UInt_t module, UInt_t sensor,
- UInt_t side, UInt_t version)
+int32_t CbmStsAddress::GetAddress(uint32_t unit, uint32_t ladder, uint32_t halfladder, uint32_t module, uint32_t sensor,
+ uint32_t side, uint32_t version)
{
assert(version <= kCurrentVersion);
// Catch overrun of allowed ranges
- UInt_t maxUnit = (1 << kBits[version][kStsUnit]) - 1;
+ uint32_t maxUnit = (1 << kBits[version][kStsUnit]) - 1;
if (unit > maxUnit) {
LOG(error) << "Unit Id " << unit << " exceeds maximum " << maxUnit;
return 0;
}
- UInt_t maxLadder = (1 << kBits[version][kStsLadder]) - 1;
+ uint32_t maxLadder = (1 << kBits[version][kStsLadder]) - 1;
if (ladder > maxLadder) {
LOG(error) << "Ladder Id " << ladder << " exceeds maximum " << maxLadder;
return 0;
}
- UInt_t maxHalfLadder = (1 << kBits[version][kStsHalfLadder]) - 1;
+ uint32_t maxHalfLadder = (1 << kBits[version][kStsHalfLadder]) - 1;
if (halfladder > maxHalfLadder) {
LOG(error) << "HalfLadder Id " << halfladder << " exceeds maximum " << maxHalfLadder;
return 0;
}
- UInt_t maxModule = (1 << kBits[version][kStsModule]) - 1;
+ uint32_t maxModule = (1 << kBits[version][kStsModule]) - 1;
if (module > maxModule) {
LOG(error) << "Module Id " << module << " exceeds maximum " << maxModule;
return 0;
}
- UInt_t maxSensor = (1 << kBits[version][kStsSensor]) - 1;
+ uint32_t maxSensor = (1 << kBits[version][kStsSensor]) - 1;
if (sensor > maxSensor) {
LOG(error) << "Sensor Id " << sensor << " exceeds maximum " << maxSensor;
return 0;
}
- UInt_t maxSide = (1 << kBits[version][kStsSide]) - 1;
+ uint32_t maxSide = (1 << kBits[version][kStsSide]) - 1;
if (side > maxSide) {
LOG(error) << "Side Id " << side << " exceeds maximum " << maxSide;
return 0;
@@ -119,14 +119,14 @@ Int_t CbmStsAddress::GetAddress(UInt_t unit, UInt_t ladder, UInt_t halfladder, U
// ----- Construct address from array of element Ids ----------------------
-Int_t CbmStsAddress::GetAddress(UInt_t* elementId, UInt_t version)
+int32_t CbmStsAddress::GetAddress(uint32_t* elementId, uint32_t version)
{
assert(version <= kCurrentVersion);
- Int_t address = ToIntegralType(ECbmModuleId::kSts) << kShift[version][kStsSystem];
- for (Int_t level = 1; level < kStsNofLevels; level++) {
- UInt_t maxId = (1 << kBits[version][level]) - 1;
+ int32_t address = ToIntegralType(ECbmModuleId::kSts) << kShift[version][kStsSystem];
+ for (int32_t level = 1; level < kStsNofLevels; level++) {
+ uint32_t maxId = (1 << kBits[version][level]) - 1;
if (elementId[level] > maxId) {
LOG(error) << "Id " << elementId[level] << " for STS level " << level << " exceeds maximum " << maxId;
return 0;
@@ -141,12 +141,12 @@ Int_t CbmStsAddress::GetAddress(UInt_t* elementId, UInt_t version)
// ----- Construct address from address of descendant element ------------
-Int_t CbmStsAddress::GetMotherAddress(Int_t address, Int_t level)
+int32_t CbmStsAddress::GetMotherAddress(int32_t address, int32_t level)
{
assert(level >= kStsSystem && level < kStsNofLevels);
if (level == kStsNofLevels - 1) return address;
- UInt_t version = GetVersion(address);
- Int_t motherAdd = (address & ((1 << kShift[version][level + 1]) - 1));
+ uint32_t version = GetVersion(address);
+ int32_t motherAdd = (address & ((1 << kShift[version][level + 1]) - 1));
motherAdd = motherAdd | (version << kVersionShift);
return motherAdd;
}
@@ -154,17 +154,17 @@ Int_t CbmStsAddress::GetMotherAddress(Int_t address, Int_t level)
// ----- Get the index of an element -------------------------------------
-UInt_t CbmStsAddress::GetElementId(Int_t address, Int_t level)
+uint32_t CbmStsAddress::GetElementId(int32_t address, int32_t level)
{
assert(level >= kStsSystem && level < kStsNofLevels);
- UInt_t version = GetVersion(address);
+ uint32_t version = GetVersion(address);
return (address & (kMask[version][level] << kShift[version][level])) >> kShift[version][level];
}
// ---------------------------------------------------------------------------
// ----- Get System ID ---------------------------------------------------
-ECbmModuleId CbmStsAddress::GetSystemId(Int_t address)
+ECbmModuleId CbmStsAddress::GetSystemId(int32_t address)
{
return static_cast<ECbmModuleId>(GetElementId(address, kStsSystem));
// return GetElementId(address, kStsSystem);
@@ -173,19 +173,19 @@ ECbmModuleId CbmStsAddress::GetSystemId(Int_t address)
// ----- Get the version number from the address -------------------------
-UInt_t CbmStsAddress::GetVersion(Int_t address)
+uint32_t CbmStsAddress::GetVersion(int32_t address)
{
- return UInt_t((address & (kVersionMask << kVersionShift)) >> kVersionShift);
+ return uint32_t((address & (kVersionMask << kVersionShift)) >> kVersionShift);
}
// ---------------------------------------------------------------------------
// ----- Construct address by changing the index of an element ------------
-Int_t CbmStsAddress::SetElementId(Int_t address, Int_t level, UInt_t newId)
+int32_t CbmStsAddress::SetElementId(int32_t address, int32_t level, uint32_t newId)
{
assert(level >= kStsSystem && level < kStsNofLevels);
- UInt_t version = GetVersion(address);
- UInt_t maxId = (1 << kBits[version][level]) - 1;
+ uint32_t version = GetVersion(address);
+ uint32_t maxId = (1 << kBits[version][level]) - 1;
if (newId > maxId) {
LOG(fatal) << "Id " << newId << " for STS level " << level << " exceeds maximum " << maxId;
return 0;
@@ -194,9 +194,28 @@ Int_t CbmStsAddress::SetElementId(Int_t address, Int_t level, UInt_t newId)
}
// -------------------------------------------------------------------------
+// ----- Pack Digi Address --------------------------------------------
+int32_t CbmStsAddress::PackDigiAddress(int32_t address)
+{
+ const 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];
+ return ret;
+}
+// -------------------------------------------------------------------------
+
+// ----- Unpack Digi Address -------------------------------------------
+int32_t CbmStsAddress::UnpackDigiAddress(int32_t digiAddress)
+{
+ return digiAddress << kShift[1][kStsUnit] | ToIntegralType(ECbmModuleId::kSts) << kShift[1][kStsSystem]
+ | 1u << kVersionShift;
+}
+// -------------------------------------------------------------------------
// ----- String output -------------------------------------------------
-std::string CbmStsAddress::ToString(Int_t address)
+std::string CbmStsAddress::ToString(int32_t address)
{
std::stringstream ss;
diff --git a/core/data/sts/CbmStsAddress.h b/core/data/sts/CbmStsAddress.h
index 454e7488e8ebaf9f9232a0c309372e0fa27a511a..e62a00feb13b4fed2b36a6a5cc3d10a807bb623a 100644
--- a/core/data/sts/CbmStsAddress.h
+++ b/core/data/sts/CbmStsAddress.h
@@ -12,8 +12,6 @@
#include "CbmDefs.h" // for ECbmModuleId
-#include <RtypesCore.h> // for Int_t, UInt_t
-
#include <sstream> // for string
/** Enumerator for the hierarchy levels of the STS setup **/
@@ -50,13 +48,13 @@ enum EStsElementLevel
namespace CbmStsAddress
{
- const UInt_t kCurrentVersion = 1;
+ const uint32_t kCurrentVersion = 1;
// --- These values are not to be changed if backward compatibility
// --- shall be maintained.
- const Int_t kVersionSize = 4; // Bits for version number
- const Int_t kVersionShift = 28; // First bit for version number
- const Int_t kVersionMask = (1 << kVersionSize) - 1;
+ const int32_t kVersionSize = 4; // Bits for version number
+ const int32_t kVersionShift = 28; // First bit for version number
+ const int32_t kVersionMask = (1 << kVersionSize) - 1;
/** @brief Construct address
@@ -69,15 +67,15 @@ namespace CbmStsAddress
** @param channel Channel number
** @return Unique element address
**/
- Int_t GetAddress(UInt_t unit = 0, UInt_t ladder = 0, UInt_t halfladder = 0, UInt_t module = 0, UInt_t sensor = 0,
- UInt_t side = 0, UInt_t version = kCurrentVersion);
+ 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);
/** @brief Construct address
** @param elementIds Array of element indices in their mother volumes
** @return Unique element address
**/
- Int_t GetAddress(UInt_t* elementId, UInt_t version);
+ int32_t GetAddress(uint32_t* elementId, uint32_t version);
/** @brief Construct the address of an element from the address of a
@@ -89,7 +87,7 @@ namespace CbmStsAddress
** This strips of the address information of all hierarchy levels
** below the desired one.
**/
- Int_t GetMotherAddress(Int_t address, Int_t level);
+ int32_t GetMotherAddress(int32_t address, int32_t level);
/** @brief Get the index of an element
@@ -97,13 +95,13 @@ namespace CbmStsAddress
** @param level Hierarchy level
** @return Element index
**/
- UInt_t GetElementId(Int_t address, Int_t level);
+ uint32_t GetElementId(int32_t address, int32_t level);
/** @brief Get system Id (should be ECbmModuleId::kSts)
** @param address Unique element address
**/
- ECbmModuleId GetSystemId(Int_t address);
+ ECbmModuleId GetSystemId(int32_t address);
/** @brief Extract version number
@@ -113,7 +111,7 @@ namespace CbmStsAddress
** The version is encoded in the last 6 bits (58 to 63).
** The maximal number of versions is 64.
**/
- UInt_t GetVersion(Int_t address);
+ uint32_t GetVersion(int32_t address);
/** @brief Set the index of an element, leaving the other element levels
@@ -123,13 +121,27 @@ namespace CbmStsAddress
** @param newId New element index
** @return New address
**/
- Int_t SetElementId(Int_t address, Int_t level, UInt_t newId);
+ int32_t SetElementId(int32_t address, int32_t level, uint32_t newId);
+
+
+ /** @brief Strip address to contain only unit, (half)ladder and module.
+ ** @param address Full address
+ ** @return 17 bit address that can be stored in a Digi
+ **/
+ int32_t PackDigiAddress(int32_t address);
+
+
+ /** @brief Add version and system to compressed address that's stored in a digi
+ ** @param digiAddress Compressed address from digi
+ ** @return Full address
+ **/
+ int32_t UnpackDigiAddress(int32_t digiAddress);
/** @brief String output
** @param address Unique element address
**/
- std::string ToString(Int_t address);
+ std::string ToString(int32_t address);
} // Namespace CbmStsAddress