CbmTrdFexMessageSpadic.h

Go to the documentation of this file.

/* Copyright (C) 2024 Goethe-University Frankfurt, Frankfurt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: David Schledt [committer] */
 
#ifndef CbmTrdFexMessageSpadic_H
#define CbmTrdFexMessageSpadic_H
 
#include "fmt/format.h"
 
#include <array>
#include <cstdint>
#include <stdexcept>
 
 
namespace Spadic
{
 
  template<uint8_t sys_ver>
  constexpr uint8_t BytesPerWord()
  {
    switch (sys_ver) {
      case 0x01: return 8;
      case 0x10: return 8;
      default: return 0;
    }
  }
 
  template<size_t bytes>
  struct NByteContainer {
    uint8_t b[bytes];
 
    operator uint64_t()
    {
      uint64_t r;
      memcpy(&r, b, sizeof(long));
      return r;
    }
 
    size_t range(uint8_t h, uint8_t l)
    {
 
      if (l > h) {
        throw std::invalid_argument(fmt::format("Reverse ranges not supported : low={:#x} > high={:#x}", l, h));
      }
      // get high and low byte positions
      uint16_t bh = h >> 3;
      uint16_t bl = l >> 3;
      // get number of bytes that need to be accessed
      uint16_t rbytes = bh - bl;
      if ((bh + 1) > bytes) {
        throw std::invalid_argument(fmt::format("High value: out-of-range, got={:#x}, size={:#x}", h, (bytes * 8 - 1)));
      }
      if ((bl + 1) > bytes) {
        throw std::invalid_argument(fmt::format("Low value: out-of-range, got={:#x}, size={:#x}", l, (bytes * 8 - 1)));
      }
      // calculate bit positions for high and low byte
      uint16_t bits_in_h = h - (8 * bh - 1);
      uint16_t bits_in_l = l - (8 * bl);
      uint16_t mask_h    = (1 << bits_in_h) - 1;
 
      // assemble return value
      size_t r = b[bl] >> bits_in_l;
      if (bh != bl) r |= (b[bh] & mask_h) << (rbytes * 8);
      for (int i = 1; i < rbytes; ++i)
        r |= b[bl + i] << (i * 8);
      return r;
    }
  };
 
  // Define template specialisations for each system version
  template<uint8_t sys_ver>
  struct FexWord {
  };
 
 
  // sys_ver 0x10 (c.f.git.cbm.gsi.de/trd/reports/technical-notes/integrated-data-format)
  template<>
  struct FexWord<0x10> {
    static constexpr int hts  = 62;
    static constexpr int els  = hts - 8;
    static constexpr int chs  = els - 4;
    static constexpr int maxs = chs - 9;
    static constexpr int imas = maxs - 3;
    static constexpr int trs  = imas - 9;
    static constexpr int mhs  = trs - 3;
    static constexpr int pts  = mhs - 5;
 
    static constexpr int m_el      = 0xff;
    static constexpr int m_ch      = 0xf;
    static constexpr int m_ts      = 0x1fffff;
    static constexpr int m_pt      = 0x1f;
    static constexpr int m_mA      = 0x1ff;
    static constexpr int m_tsample = 0x1ff;
    static constexpr int m_iMA     = 0x7;
    static constexpr int m_ht      = 0x3;
    static constexpr int m_mh      = 0x7;
 
    uint8_t elink;
    uint8_t channel;
    uint64_t timestamp;
    float prec_time;
    uint16_t maxAdc;
    uint16_t timesample;
    uint8_t iMA;
    uint8_t ht;
    uint8_t mh;
 
    FexWord(NByteContainer<BytesPerWord<0x10>()> word)
    {
 
      uint64_t w = word;
 
      ht = (word >> 62) & 0x3;  // TODO ext trigger
      if (ht != 0) {
        elink      = (w >> els) & m_el;
        channel    = (w >> chs) & m_ch;
        maxAdc     = (w >> maxs) & m_mA;
        iMA        = (w >> imas) & m_iMA;
        timesample = (w >> trs) & m_tsample;
        mh         = (w >> mhs) & m_mh;
        prec_time  = (float) ((w >> pts) & m_pt) / float(1 << 4);
        timestamp  = w & m_ts;
      }
    }
 
    FexWord(uint8_t elink_v, uint8_t channel_v, uint64_t timestamp_v, uint8_t prec_time_v, uint16_t maxAdc_v,
            uint16_t timesample_v, uint8_t iMA_v, uint8_t ht_v, uint8_t mh_v)
      : elink(elink_v & m_el)
      , channel(channel_v & m_ch)
      , timestamp(timestamp_v & m_ts)
      , prec_time((float) (prec_time_v & m_pt) / float(1 << 4))
      , maxAdc(maxAdc_v & m_mA)
      , timesample(timesample_v & m_tsample)
      , iMA(iMA_v & m_iMA)
      , ht(ht_v & m_ht)
      , mh(mh_v & m_mh)
    {
    }
 
    operator uint64_t()
    {
      uint8_t prec_time_fixed_point = prec_time * (1 << 4);
      uint64_t fw                   = 0 | (uint64_t) ht << 62 | (uint64_t) elink << els | (uint64_t) channel << chs
                    | (uint64_t) maxAdc << maxs | (uint64_t) iMA << imas | (uint64_t) timesample << trs
                    | (uint64_t) mh << mhs | (uint64_t) prec_time_fixed_point << pts | timestamp;
      return fw;
    }
 
    operator NByteContainer<BytesPerWord<0x10>()>()
    {
 
      NByteContainer<BytesPerWord<0x10>()> nbc;
      uint64_t fw = *this;
      memcpy(&nbc.b, &fw, sizeof(long));
      return nbc;
    }
  };
 
}  // namespace Spadic
 
#endif  // CbmTrdFexMessageSpadic_H