FragmentHeader.hpp

Go to the documentation of this file.

 
#ifndef DAQDATAFORMATS_INCLUDE_DAQDATAFORMATS_FRAGMENTHEADER_HPP_
#define DAQDATAFORMATS_INCLUDE_DAQDATAFORMATS_FRAGMENTHEADER_HPP_
 
#include "daqdataformats/SourceID.hpp"
#include "daqdataformats/Types.hpp"
 
#include <bitset>
#include <cstddef>
#include <cstdlib>
#include <map>
#include <numeric>
#include <string>
#include <vector>
 
namespace dunedaq::daqdataformats {
 
struct FragmentHeader
{
  static constexpr uint32_t s_fragment_header_marker = 0x11112222; // NOLINT(build/unsigned)
 
  static constexpr uint32_t s_fragment_header_version = 6; // NOLINT(build/unsigned)
 
  static constexpr uint32_t s_default_status_bits = 0; // NOLINT(build/unsigned)
 
  uint32_t fragment_header_marker = s_fragment_header_marker; // NOLINT(build/unsigned)
 
  uint32_t version = s_fragment_header_version; // NOLINT(build/unsigned)
 
  fragment_size_t size{ TypeDefaults::s_invalid_fragment_size }; // NOLINT(build/unsigned)
 
  trigger_number_t trigger_number{ TypeDefaults::s_invalid_trigger_number };
 
  timestamp_t trigger_timestamp{ TypeDefaults::s_invalid_timestamp };
 
  timestamp_t window_begin{ TypeDefaults::s_invalid_timestamp };
 
  timestamp_t window_end{ TypeDefaults::s_invalid_timestamp };
 
  run_number_t run_number{ TypeDefaults::s_invalid_run_number };
 
  uint32_t status_bits{ s_default_status_bits }; // NOLINT(build/unsigned)
 
  fragment_type_t fragment_type{ TypeDefaults::s_invalid_fragment_type };
 
  sequence_number_t sequence_number{ TypeDefaults::s_invalid_sequence_number };
 
  uint16_t detector_id; // NOLINT(build/unsigned)
 
  SourceID element_id;
 
  //  uint32_t unused2{ // NOLINT(build/unsigned)
  //                   0xFFFFFFFF
  //  }; ///< Padding to ensure 64-bit alignment of FragmentHeader basic fields
};
 
static_assert(FragmentHeader::s_fragment_header_version == 6,
              "This is intentionally designed to tell the developer to update the static_assert checks (including this "
              "one) when the version is bumped");
 
static_assert(sizeof(FragmentHeader) == 72, "FragmentHeader struct size different than expected!");
static_assert(offsetof(FragmentHeader, fragment_header_marker) == 0,
              "FragmentHeader fragment_header_marker field not at expected offset!");
static_assert(offsetof(FragmentHeader, version) == 4, "FragmentHeader version field not at expected offset!");
static_assert(offsetof(FragmentHeader, size) == 8, "FragmentHeader size field not at expected offset!");
static_assert(offsetof(FragmentHeader, trigger_number) == 16,
              "FragmentHeader trigger_number field not at expected offset!");
static_assert(offsetof(FragmentHeader, trigger_timestamp) == 24,
              "FragmentHeader trigger_timestamp field not at expected offset!");
static_assert(offsetof(FragmentHeader, window_begin) == 32,
              "FragmentHeader window_begin field not at expected offset!");
static_assert(offsetof(FragmentHeader, window_end) == 40, "FragmentHeader window_end field not at expected offset!");
static_assert(offsetof(FragmentHeader, run_number) == 48, "FragmentHeader run_number field not at expected offset!");
static_assert(offsetof(FragmentHeader, status_bits) == 52, "FragmentHeader status_bits field not at expected offset!");
static_assert(offsetof(FragmentHeader, fragment_type) == 56,
              "FragmentHeader fragment_type field not at expected offset!");
static_assert(offsetof(FragmentHeader, sequence_number) == 60,
              "FragmentHeader sequence_number field not at expected offset!");
static_assert(offsetof(FragmentHeader, detector_id) == 62, "FragmentHeader detector_id field not at expected offset!");
static_assert(offsetof(FragmentHeader, element_id) == 64, "FragmentHeader element_id field not at expected offset!");
 
enum class FragmentStatusBits : size_t
{
  kLatencyBufferEmpty = 0,        
  kIncomplete = 1,                
  kInvalidRequestWindow = 2,      
  kRequestTimeout = 3,            
  kRequestWindowBeforeBuffer = 4, 
  kRequestWindowAfterBuffer = 5,  
  kEmptyFragment = 6,             
  kUnassigned7 = 7,               
  kUnassigned8 = 8,               
  kUnassigned9 = 9,               
  kUnassigned10 = 10,             
  kUnassigned11 = 11,             
  kUnassigned12 = 12,             
  kUnassigned13 = 13,             
  kUnassigned14 = 14,             
  kUnassigned15 = 15,             
  kUnassigned16 = 16,             
  kUnassigned17 = 17,             
  kUnassigned18 = 18,             
  kUnassigned19 = 19,             
  kUnassigned20 = 20,             
  kUnassigned21 = 21,             
  kUnassigned22 = 22,             
  kUnassigned23 = 23,             
  kUnassigned24 = 24,             
  kUnassigned25 = 25,             
  kUnassigned26 = 26,             
  kUnassigned27 = 27,             
  kUnassigned28 = 28,             
  kUnassigned29 = 29,             
  kUnassigned30 = 30,             
  kUnassigned31 = 31,             
  kInvalid = 32                   
};
 
enum class FragmentType : fragment_type_t
{
  kUnknown = 0,
  kProtoWIB = 1,
  kWIB = 2,
  kDAPHNE = 3,
  kTDE_AMC = 4,
  // This fragment type is for the "raw" data from the firmware
  // trigger primitive generation. We store this in fragments for the
  // purposes of inspecting/debugging the firmware TPG
  kFW_TriggerPrimitive = 5, 
  // This fragment type is for TPs saved via the trigger subsystem's
  // TP buffer, which are in the format defined by
  // dunedaq::trgdataformats::TriggerPrimitive. It is also
  // used for the stream of TPs that are sent directly from the readout
  // subsystem to the dataflow subsystem for storage on disk.
  // TPs stored in this format may have been _originally_ produced
  // by either software _or_ firmware.
  kTriggerPrimitive = 6, 
  kTriggerActivity = 7,
  kTriggerCandidate = 8,
  kHardwareSignal = 9,
  kPACMAN = 10,
  kMPD = 11,
  kWIBEth = 12,
  kDAPHNEStream = 13,
  kCRT = 14,
  kTDEEth = 15,
  kCRTBern = 16,
  kCRTGrenoble = 17,
  kDAPHNEEth = 18,
  kDAPHNEEthStream = 19
};
 
inline std::map<FragmentType, std::string>
get_fragment_type_names()
{
  return {
    { FragmentType::kUnknown, "Unknown" },
    { FragmentType::kProtoWIB, "ProtoWIB" },
    { FragmentType::kWIB, "WIB" },
    { FragmentType::kDAPHNE, "DAPHNE" },
    { FragmentType::kDAPHNEStream, "DAPHNEStream" },
    { FragmentType::kTDE_AMC, "TDE_AMC" },
    { FragmentType::kFW_TriggerPrimitive, "FW_Trigger_Primitive" },
    { FragmentType::kTriggerPrimitive, "Trigger_Primitive" },
    { FragmentType::kTriggerActivity, "Trigger_Activity" },
    { FragmentType::kTriggerCandidate, "Trigger_Candidate" },
    { FragmentType::kHardwareSignal, "Hardware_Signal" },
    { FragmentType::kPACMAN, "PACMAN" },
    { FragmentType::kMPD, "MPD" },
    { FragmentType::kWIBEth, "WIBEth" },
    { FragmentType::kCRT, "CRT" },
    { FragmentType::kTDEEth, "TDEEth" },
    { FragmentType::kCRTBern, "CRTBern" },
    { FragmentType::kCRTGrenoble, "CRTGrenoble" },
    { FragmentType::kDAPHNEEth, "DAPHNEEth" },
    { FragmentType::kDAPHNEEthStream, "DAPHNEEthStream" },
  };
}
 
inline std::string
fragment_type_to_string(const FragmentType& type)
{
  try {
    return get_fragment_type_names().at(type);
  } catch (std::exception& e) {
  }
  return "Unknown";
}
 
inline FragmentType
string_to_fragment_type(const std::string& name)
{
  for (auto& it : get_fragment_type_names()) {
    if (it.second == name)
      return it.first;
  }
  return FragmentType::kUnknown;
}
 
inline std::ostream&
operator<<(std::ostream& o, FragmentHeader const& hdr)
{
  return o << "check_word: " << std::hex << hdr.fragment_header_marker << std::dec << ", " << "version: " << hdr.version
           << ", " << "size: " << hdr.size << ", " << "trigger_number: " << hdr.trigger_number << ", "
           << "run_number: " << hdr.run_number << ", " << "trigger_timestamp: " << hdr.trigger_timestamp << ", "
           << "window_begin: " << hdr.window_begin << ", " << "window_end: " << hdr.window_end << ", "
           << "status_bits: " << hdr.status_bits << ", " << "fragment_type: " << hdr.fragment_type << ", "
           << "sequence_number: " << hdr.sequence_number << ", " << "detector_id: " << hdr.detector_id << ", "
           << "element_id: " << hdr.element_id;
}
 
inline std::istream&
operator>>(std::istream& o, FragmentHeader& hdr)
{
  std::string tmp;
  return o >> tmp >> std::hex >> hdr.fragment_header_marker >> std::dec >> tmp >> tmp >> hdr.version >> tmp >> tmp >>
         hdr.size >> tmp >> tmp >> hdr.trigger_number >> tmp >> tmp >> hdr.run_number >> tmp >> tmp >>
         hdr.trigger_timestamp >> tmp >> tmp >> hdr.window_begin >> tmp >> tmp >> hdr.window_end >> tmp >> tmp >>
         hdr.status_bits >> tmp >> tmp >> hdr.fragment_type >> tmp >> tmp >> hdr.sequence_number >> tmp >> tmp >>
         hdr.detector_id >> tmp >> tmp >> hdr.element_id;
}
} // namespace dunedaq::daqdataformats
 
#endif // DAQDATAFORMATS_INCLUDE_DAQDATAFORMATS_FRAGMENTHEADER_HPP_