SiStripChannelMap.h

#ifndef TRACKING_RECO_SISTRIPCHANNELMAP_H_
#define TRACKING_RECO_SISTRIPCHANNELMAP_H_
 
#include <cstdint>
#include <cstdio>
#include <string>
 
namespace tracking::reco {
 
namespace channelmap {
 
inline constexpr int K_CHANNELS_PER_APV = 128;
inline constexpr int K_APVS_PER_HYBRID = 5;
inline constexpr int K_CHANNELS_PER_HYBRID =
    K_APVS_PER_HYBRID * K_CHANNELS_PER_APV;
inline constexpr int K_SAMPLES_PER_APV_TRIGGER = 3;
 
inline constexpr int16_t pchannel(uint8_t apv_id, uint8_t channel) {
  return static_cast<int16_t>(
      (K_CHANNELS_PER_HYBRID - 1) -
      (apv_id * K_CHANNELS_PER_APV + (K_CHANNELS_PER_APV - 1) - channel));
}
 
inline constexpr void apvChannelFromPchannel(int16_t pchannel, uint8_t& apv_id,
                                             uint8_t& channel) {
  const int x = (K_CHANNELS_PER_HYBRID - 1) - pchannel;
  apv_id = static_cast<uint8_t>(x / K_CHANNELS_PER_APV);
  channel =
      static_cast<uint8_t>((K_CHANNELS_PER_APV - 1) - (x % K_CHANNELS_PER_APV));
}
 
inline constexpr int stripId(int16_t pchannel, int n_strips, int first_strip,
                             bool reversed) {
  return reversed ? first_strip + n_strips - 1 - pchannel
                  : first_strip + pchannel;
}
 
inline std::string channelKey(uint8_t feb, uint8_t hybrid, uint8_t apv,
                              uint8_t channel) {
  return std::to_string(feb) + ":" + std::to_string(hybrid) + ":" +
         std::to_string(apv) + ":" + std::to_string(channel);
}
 
inline constexpr uint32_t channelId(uint8_t feb, uint8_t hybrid, uint8_t apv,
                                    uint8_t channel) {
  return (static_cast<uint32_t>(feb) << 24) |
         (static_cast<uint32_t>(hybrid) << 16) |
         (static_cast<uint32_t>(apv) << 8) | static_cast<uint32_t>(channel);
}
 
inline bool parseChannelKey(const std::string& key, uint8_t& feb,
                            uint8_t& hybrid, uint8_t& apv, uint8_t& channel) {
  unsigned f, h, a, c;
  if (std::sscanf(key.c_str(), "%u:%u:%u:%u", &f, &h, &a, &c) != 4)
    return false;
  feb = static_cast<uint8_t>(f);
  hybrid = static_cast<uint8_t>(h);
  apv = static_cast<uint8_t>(a);
  channel = static_cast<uint8_t>(c);
  return true;
}
 
inline constexpr uint32_t groupKey(uint8_t feb, uint8_t hybrid,
                                   int16_t pchannel) {
  return (static_cast<uint32_t>(feb) << 24) |
         (static_cast<uint32_t>(hybrid) << 16) |
         static_cast<uint32_t>(static_cast<uint16_t>(pchannel));
}
 
inline constexpr int16_t pchannelFromGroupKey(uint32_t key) {
  return static_cast<int16_t>(key & 0xFFFF);
}
 
}  // namespace channelmap
}  // namespace tracking::reco
 
#endif  // TRACKING_RECO_SISTRIPCHANNELMAP_H_