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