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 = 5; // NOLINT(build/unsigned)
 
  static constexpr uint32_t s_default_error_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 error_bits{ s_default_error_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;
 
  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 == 5,
             "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, error_bits) == 52, "FragmentHeader error_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 FragmentErrorBits : size_t
{
  kDataNotFound = 0,  
  kIncomplete = 1,    
  kInvalidWindow = 2, 
  kUnassigned3 = 3,   
  kUnassigned4 = 4,   
  kUnassigned5 = 5,   
  kUnassigned6 = 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,
};
 
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"},
  };
}
 
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 << ", "
           << "error_bits: " << hdr.error_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.error_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_