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;
};

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" },
  };
}
 
std::string
fragment_type_to_string(const FragmentType& type);
 
FragmentType
string_to_fragment_type(const std::string& name);
 
std::ostream&
operator<<(std::ostream& o, FragmentHeader const& hdr);
 
} // namespace dunedaq::daqdataformats
 
#include "detail/FragmentHeader.hxx"
 
#endif // DAQDATAFORMATS_INCLUDE_DAQDATAFORMATS_FRAGMENTHEADER_HPP_