00001 #ifndef artdaq_core_Data_detail_RawFragmentHeader_hh
00002 #define artdaq_core_Data_detail_RawFragmentHeader_hh
00003
00004
00005
00006
00007
00008 #include <cstddef>
00009 #include "artdaq-core/Data/dictionarycontrol.hh"
00010 #include "cetlib/exception.h"
00011
00012 extern "C" {
00013 #include <stdint.h>
00014 }
00015
00016 namespace artdaq {
00017 namespace detail {
00018 struct RawFragmentHeader;
00019 }
00020 }
00021
00022 struct artdaq::detail::RawFragmentHeader {
00023 typedef unsigned long long RawDataType;
00024
00025 #if HIDE_FROM_ROOT
00026 typedef uint16_t version_t;
00027 typedef uint64_t sequence_id_t;
00028 typedef uint8_t type_t;
00029 typedef uint16_t fragment_id_t;
00030 typedef uint8_t metadata_word_count_t;
00031 typedef uint32_t timestamp_t;
00032
00033
00034 static constexpr type_t INVALID_TYPE = 0;
00035 static constexpr type_t FIRST_USER_TYPE = 1;
00036 static constexpr type_t LAST_USER_TYPE = 224;
00037 static constexpr type_t FIRST_SYSTEM_TYPE = 225;
00038 static constexpr type_t LAST_SYSTEM_TYPE = 255;
00039 static constexpr type_t InvalidFragmentType = INVALID_TYPE;
00040 static constexpr type_t EndOfDataFragmentType = FIRST_SYSTEM_TYPE;
00041 static constexpr type_t DataFragmentType = FIRST_SYSTEM_TYPE+1;
00042 static constexpr type_t InitFragmentType = FIRST_SYSTEM_TYPE+2;
00043 static constexpr type_t EndOfRunFragmentType = FIRST_SYSTEM_TYPE+3;
00044 static constexpr type_t EndOfSubrunFragmentType = FIRST_SYSTEM_TYPE+4;
00045 static constexpr type_t ShutdownFragmentType = FIRST_SYSTEM_TYPE+5;
00046 static constexpr type_t EmptyFragmentType = FIRST_SYSTEM_TYPE+6;
00047 static constexpr type_t ContainerFragmentType = FIRST_SYSTEM_TYPE+7;
00048
00049
00050 static std::map<type_t, std::string> MakeSystemTypeMap()
00051 {
00052 return std::map<type_t, std::string> {
00053 { 226, "Data" },
00054 { 231, "Empty" },
00055 { 232, "Container" }
00056 };
00057 }
00058
00059 static std::map<type_t, std::string> MakeVerboseSystemTypeMap()
00060 {
00061 return std::map<type_t, std::string> {
00062 { 225, "EndOfData" },
00063 { 226, "Data" },
00064 { 227, "Init" },
00065 { 228, "EndOfRun" },
00066 { 229, "EndOfSubrun" },
00067 { 230,"Shutdown" },
00068 { 231, "Empty" },
00069 { 232, "Container" }
00070 };
00071 }
00072
00073
00074
00075
00076
00077 static const version_t InvalidVersion = 0xFFFF;
00078 static const sequence_id_t InvalidSequenceID = 0xFFFFFFFFFFFF;
00079 static const fragment_id_t InvalidFragmentID = 0xFFFF;
00080 static const timestamp_t InvalidTimestamp = 0xFFFFFFFF;
00081
00082 RawDataType word_count : 32;
00083 RawDataType version : 16;
00084 RawDataType type : 8;
00085 RawDataType metadata_word_count : 8;
00086
00087 RawDataType sequence_id : 48;
00088 RawDataType fragment_id : 16;
00089 RawDataType timestamp : 32;
00090
00091
00092
00093
00094
00095 RawDataType unused1 : 16;
00096 RawDataType unused2 : 16;
00097
00098 constexpr static std::size_t num_words();
00099
00100 void setUserType(uint8_t utype);
00101 void setSystemType(uint8_t stype);
00102
00103 #endif
00104
00105 };
00106
00107 #if HIDE_FROM_ROOT
00108 inline
00109 constexpr
00110 std::size_t
00111 artdaq::detail::RawFragmentHeader::num_words()
00112 {
00113 return sizeof(detail::RawFragmentHeader) / sizeof(RawDataType);
00114 }
00115
00116
00117
00118 static_assert((artdaq::detail::RawFragmentHeader::num_words() *
00119 sizeof(artdaq::detail::RawFragmentHeader::RawDataType)) ==
00120 sizeof(artdaq::detail::RawFragmentHeader),
00121 "sizeof(RawFragmentHeader) is not an integer "
00122 "multiple of sizeof(RawDataType)!");
00123
00124 inline
00125 void
00126 artdaq::detail::RawFragmentHeader::setUserType(uint8_t utype)
00127 {
00128 if (utype < FIRST_USER_TYPE || utype > LAST_USER_TYPE) {
00129 throw cet::exception("InvalidValue")
00130 << "RawFragmentHeader user types must be in the range of "
00131 << ((int)FIRST_USER_TYPE) << " to " << ((int)LAST_USER_TYPE)
00132 << " (bad type is " << ((int)utype) << ").";
00133 }
00134 type = utype;
00135 }
00136
00137 inline
00138 void
00139 artdaq::detail::RawFragmentHeader::setSystemType(uint8_t stype)
00140 {
00141 if (stype < FIRST_SYSTEM_TYPE /*|| stype > LAST_SYSTEM_TYPE*/) {
00142 throw cet::exception("InvalidValue")
00143 << "RawFragmentHeader system types must be in the range of "
00144 << ((int)FIRST_SYSTEM_TYPE) << " to " << ((int)LAST_SYSTEM_TYPE);
00145 }
00146 type = stype;
00147 }
00148 #endif
00149
00150 #endif