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 {
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
00068 static std::map<type_t, std::string> MakeSystemTypeMap()
00069 {
00070 return std::map<type_t, std::string>{
00071 { type_t(DataFragmentType), "Data"},
00072 { type_t(EmptyFragmentType), "Empty" },
00073 { 232, "Container" }
00074 };
00075 }
00076
00081 static std::map<type_t, std::string> MakeVerboseSystemTypeMap()
00082 {
00083 return std::map<type_t, std::string>{
00084 { type_t(EndOfDataFragmentType), "EndOfData" },
00085 { type_t(DataFragmentType), "Data" },
00086 { type_t(InitFragmentType), "Init" },
00087 { type_t(EndOfRunFragmentType), "EndOfRun" },
00088 { type_t(EndOfSubrunFragmentType), "EndOfSubrun" },
00089 { type_t(ShutdownFragmentType),"Shutdown" },
00090 { type_t(EmptyFragmentType), "Empty" },
00091 { type_t(ContainerFragmentType), "Container" }
00092 };
00093 }
00094
00100 static std::string SystemTypeToString(type_t type) {
00101 switch (type) {
00102 case INVALID_TYPE:
00103 return "INVALID";
00104 case EndOfDataFragmentType:
00105 return "EndOfData";
00106 case DataFragmentType:
00107 return "Data";
00108 case InitFragmentType:
00109 return "Init";
00110 case EndOfRunFragmentType:
00111 return "EndOfRun";
00112 case EndOfSubrunFragmentType:
00113 return "EndOfSubrun";
00114 case ShutdownFragmentType:
00115 return "Shutdown";
00116 case EmptyFragmentType:
00117 return "Empty";
00118 case ContainerFragmentType:
00119 return "Container";
00120 }
00121 return "Unknown";
00122 }
00123
00124
00125
00126
00127
00128 static const version_t InvalidVersion = 0xFFFF;
00129 static const version_t CurrentVersion = 0x1;
00130 static const sequence_id_t InvalidSequenceID = 0xFFFFFFFFFFFF;
00131 static const fragment_id_t InvalidFragmentID = 0xFFFF;
00132 static const timestamp_t InvalidTimestamp = 0xFFFFFFFFFFFFFFFF;
00133
00134 RawDataType word_count : 32;
00135 RawDataType version : 16;
00136 RawDataType type : 8;
00137 RawDataType metadata_word_count : 8;
00138
00139 RawDataType sequence_id : 48;
00140 RawDataType fragment_id : 16;
00141 RawDataType timestamp : 64;
00142
00143
00144
00145
00146
00147
00152 static constexpr std::size_t num_words();
00153
00159 void setUserType(uint8_t utype);
00160
00166 void setSystemType(uint8_t stype);
00167
00168 #endif
00169 };
00170
00171 #if HIDE_FROM_ROOT
00172 inline
00173 constexpr
00174 std::size_t
00175 artdaq::detail::RawFragmentHeader::num_words()
00176 {
00177 return sizeof(detail::RawFragmentHeader) / sizeof(RawDataType);
00178 }
00179
00180
00181
00182
00183 static_assert((artdaq::detail::RawFragmentHeader::num_words() *
00184 sizeof(artdaq::detail::RawFragmentHeader::RawDataType)) ==
00185 sizeof(artdaq::detail::RawFragmentHeader),
00186 "sizeof(RawFragmentHeader) is not an integer "
00187 "multiple of sizeof(RawDataType)!");
00188
00189 inline
00190 void
00191 artdaq::detail::RawFragmentHeader::setUserType(uint8_t utype)
00192 {
00193 if (utype < FIRST_USER_TYPE || utype > LAST_USER_TYPE)
00194 {
00195 throw cet::exception("InvalidValue")
00196 << "RawFragmentHeader user types must be in the range of "
00197 << ((int)FIRST_USER_TYPE) << " to " << ((int)LAST_USER_TYPE)
00198 << " (bad type is " << ((int)utype) << ").";
00199 }
00200 type = utype;
00201 }
00202
00203 inline
00204 void
00205 artdaq::detail::RawFragmentHeader::setSystemType(uint8_t stype)
00206 {
00207 if (stype < FIRST_SYSTEM_TYPE /*|| stype > LAST_SYSTEM_TYPE*/)
00208 {
00209 throw cet::exception("InvalidValue")
00210 << "RawFragmentHeader system types must be in the range of "
00211 << ((int)FIRST_SYSTEM_TYPE) << " to " << ((int)LAST_SYSTEM_TYPE);
00212 }
00213 type = stype;
00214 }
00215 #endif
00216
00217 #endif