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_except/exception.h"
00011 #include <map>
00012
00013 extern "C"
00014 {
00015 #include <stdint.h>
00016 }
00017
00018 namespace artdaq
00019 {
00020 namespace detail
00021 {
00022 struct RawFragmentHeader;
00023 }
00024 }
00025
00033 struct artdaq::detail::RawFragmentHeader
00034 {
00038 typedef unsigned long long RawDataType;
00039
00040 #if HIDE_FROM_ROOT
00041 typedef uint16_t version_t;
00042 typedef uint64_t sequence_id_t;
00043 typedef uint8_t type_t;
00044 typedef uint16_t fragment_id_t;
00045 typedef uint8_t metadata_word_count_t;
00046 typedef uint64_t timestamp_t;
00047
00048
00049 static constexpr type_t INVALID_TYPE = 0;
00050 static constexpr type_t FIRST_USER_TYPE = 1;
00051 static constexpr type_t LAST_USER_TYPE = 224;
00052 static constexpr type_t FIRST_SYSTEM_TYPE = 225;
00053 static constexpr type_t LAST_SYSTEM_TYPE = 255;
00054 static constexpr type_t InvalidFragmentType = INVALID_TYPE;
00055 static constexpr type_t EndOfDataFragmentType = FIRST_SYSTEM_TYPE;
00056 static constexpr type_t DataFragmentType = FIRST_SYSTEM_TYPE + 1;
00057 static constexpr type_t InitFragmentType = FIRST_SYSTEM_TYPE + 2;
00058 static constexpr type_t EndOfRunFragmentType = FIRST_SYSTEM_TYPE + 3;
00059 static constexpr type_t EndOfSubrunFragmentType = FIRST_SYSTEM_TYPE + 4;
00060 static constexpr type_t ShutdownFragmentType = FIRST_SYSTEM_TYPE + 5;
00061 static constexpr type_t EmptyFragmentType = FIRST_SYSTEM_TYPE + 6;
00062 static constexpr type_t ContainerFragmentType = FIRST_SYSTEM_TYPE + 7;
00063 static constexpr type_t ErrorFragmentType = FIRST_SYSTEM_TYPE + 8;
00064
00069 static std::map<type_t, std::string> MakeSystemTypeMap()
00070 {
00071 return std::map<type_t, std::string>{
00072 { type_t(DataFragmentType), "Data"},
00073 { type_t(EmptyFragmentType), "Empty" },
00074 { 232, "Container" }
00075 };
00076 }
00077
00082 static std::map<type_t, std::string> MakeVerboseSystemTypeMap()
00083 {
00084 return std::map<type_t, std::string>{
00085 { type_t(EndOfDataFragmentType), "EndOfData" },
00086 { type_t(DataFragmentType), "Data" },
00087 { type_t(InitFragmentType), "Init" },
00088 { type_t(EndOfRunFragmentType), "EndOfRun" },
00089 { type_t(EndOfSubrunFragmentType), "EndOfSubrun" },
00090 { type_t(ShutdownFragmentType),"Shutdown" },
00091 { type_t(EmptyFragmentType), "Empty" },
00092 { type_t(ContainerFragmentType), "Container" }
00093 };
00094 }
00095
00101 static std::string SystemTypeToString(type_t type) {
00102 switch (type) {
00103 case INVALID_TYPE:
00104 return "INVALID";
00105 case EndOfDataFragmentType:
00106 return "EndOfData";
00107 case DataFragmentType:
00108 return "Data";
00109 case InitFragmentType:
00110 return "Init";
00111 case EndOfRunFragmentType:
00112 return "EndOfRun";
00113 case EndOfSubrunFragmentType:
00114 return "EndOfSubrun";
00115 case ShutdownFragmentType:
00116 return "Shutdown";
00117 case EmptyFragmentType:
00118 return "Empty";
00119 case ContainerFragmentType:
00120 return "Container";
00121 }
00122 return "Unknown";
00123 }
00124
00125
00126
00127
00128
00129 static const version_t InvalidVersion = 0xFFFF;
00130 static const version_t CurrentVersion = 0x1;
00131 static const sequence_id_t InvalidSequenceID = 0xFFFFFFFFFFFF;
00132 static const fragment_id_t InvalidFragmentID = 0xFFFF;
00133 static const timestamp_t InvalidTimestamp = 0xFFFFFFFFFFFFFFFF;
00134
00135 RawDataType word_count : 32;
00136 RawDataType version : 16;
00137 RawDataType type : 8;
00138 RawDataType metadata_word_count : 8;
00139
00140 RawDataType sequence_id : 48;
00141 RawDataType fragment_id : 16;
00142 RawDataType timestamp : 64;
00143
00144
00145
00146
00147
00148
00153 static constexpr std::size_t num_words();
00154
00160 void setUserType(uint8_t utype);
00161
00167 void setSystemType(uint8_t stype);
00168
00169 #endif
00170 };
00171
00172 #if HIDE_FROM_ROOT
00173 inline
00174 constexpr
00175 std::size_t
00176 artdaq::detail::RawFragmentHeader::num_words()
00177 {
00178 return sizeof(detail::RawFragmentHeader) / sizeof(RawDataType);
00179 }
00180
00181
00182
00183
00184 static_assert((artdaq::detail::RawFragmentHeader::num_words() *
00185 sizeof(artdaq::detail::RawFragmentHeader::RawDataType)) ==
00186 sizeof(artdaq::detail::RawFragmentHeader),
00187 "sizeof(RawFragmentHeader) is not an integer "
00188 "multiple of sizeof(RawDataType)!");
00189
00190 inline
00191 void
00192 artdaq::detail::RawFragmentHeader::setUserType(uint8_t utype)
00193 {
00194 if (utype < FIRST_USER_TYPE || utype > LAST_USER_TYPE)
00195 {
00196 throw cet::exception("InvalidValue")
00197 << "RawFragmentHeader user types must be in the range of "
00198 << ((int)FIRST_USER_TYPE) << " to " << ((int)LAST_USER_TYPE)
00199 << " (bad type is " << ((int)utype) << ").";
00200 }
00201 type = utype;
00202 }
00203
00204 inline
00205 void
00206 artdaq::detail::RawFragmentHeader::setSystemType(uint8_t stype)
00207 {
00208 if (stype < FIRST_SYSTEM_TYPE /*|| stype > LAST_SYSTEM_TYPE*/)
00209 {
00210 throw cet::exception("InvalidValue")
00211 << "RawFragmentHeader system types must be in the range of "
00212 << ((int)FIRST_SYSTEM_TYPE) << " to " << ((int)LAST_SYSTEM_TYPE);
00213 }
00214 type = stype;
00215 }
00216 #endif
00217
00218 #endif