DAPHNEStreamFrame.hpp

Go to the documentation of this file.

 
#ifndef FDDETDATAFORMATS_INCLUDE_FDDETDATAFORMATS_DAPHNESTREAMFRAME_HPP_
#define FDDETDATAFORMATS_INCLUDE_FDDETDATAFORMATS_DAPHNESTREAMFRAME_HPP_
 
#include "Utils.hpp"
 
#include "detdataformats/DAQHeader.hpp" // For unified DAQ header
 
#include <algorithm> // For std::min
#include <cassert>   // For assert()
#include <cstdint>   // For uint32_t etc
#include <cstdio>
#include <cstdlib>
#include <stdexcept> // For std::out_of_range
 
namespace dunedaq::fddetdataformats {
 
// NOLINTBEGIN(build/unsigned)
 
class DAPHNEStreamFrame
{
public:
  // The definition of the format is in terms of 32-bit words
  using word_t = uint32_t;
 
  static constexpr int s_bits_per_adc = 14;
  static constexpr int s_bits_per_word = 8 * sizeof(word_t);
  static constexpr int s_channels_per_frame = 4;
  static constexpr int s_adcs_per_channel = 64;
  static constexpr int s_daphnes_per_frame = 1;
  static constexpr int s_num_adc_words = s_channels_per_frame * s_adcs_per_channel * s_bits_per_adc / s_bits_per_word;
 
  struct Header
  {
    word_t channel_0 : 6, channel_1 : 6, channel_2 : 6, channel_3 : 6, tbd_0 : 8;
    word_t tbd_1 : 32;
  };
  static_assert(sizeof(Header) == 8);
 
  struct Trailer
  {
    word_t tbd : 32;
  };
  static_assert(sizeof(Trailer) == 4);
 
  detdataformats::DAQHeader daq_header;
  Header header;
  word_t adc_words[s_num_adc_words]; // NOLINT (a false accusation from the linter that s_num_adc_words is a variable)
  Trailer trailer;
 
  uint64_t get_timestamp() const { return daq_header.get_timestamp(); }

  void set_timestamp(const uint64_t new_timestamp)
  {
    daq_header.timestamp_1 = new_timestamp;
    daq_header.timestamp_2 = new_timestamp >> 32;
  }

  uint16_t get_adc(uint i_adc, uint i_channel) const;

  void set_adc(uint i, uint chn, uint16_t val);

  uint8_t get_channel0() const { return header.channel_0; }

  uint8_t get_channel1() const { return header.channel_1; }

  uint8_t get_channel2() const { return header.channel_2; }

  uint8_t get_channel3() const { return header.channel_3; }
};
static_assert(sizeof(DAPHNEStreamFrame) == sizeof(detdataformats::DAQHeader) + sizeof(DAPHNEStreamFrame::Header) +
                                             sizeof(DAPHNEStreamFrame::word_t) * DAPHNEStreamFrame::s_num_adc_words +
                                             sizeof(DAPHNEStreamFrame::Trailer));
 
static_assert(std::endian::native == std::endian::little,
              "The DAPHNEStreamFrame bitfield layout assumes little-endian architecture");
 
static_assert(std::is_trivially_copyable_v<DAPHNEStreamFrame>,
              "DAPHNEStreamFrame isn't trivially copyable and can't be safely std::memcpy'd");
static_assert(std::is_standard_layout_v<DAPHNEStreamFrame>,
              "DAPHNEStreamFrame isn't standard layout; reinterpret_cast and offsetof can't safely be used with it");
 
} // namespace dunedaq::fddetdataformats
 
#include "detail/DAPHNEStreamFrame.hxx"
 
// NOLINTEND(build/unsigned)
 
#endif // FDDETDATAFORMATS_INCLUDE_FDDETDATAFORMATS_DAPHNESTREAMFRAME_HPP_