artdaq_core  v3_05_04
RawFragmentHeaderV1.hh
1 #ifndef artdaq_core_Data_detail_RawFragmentHeaderV1_hh
2 #define artdaq_core_Data_detail_RawFragmentHeaderV1_hh
3 // detail::RawFragmentHeaderV1 is an overlay that provides the user's view
4 // of the data contained within a Fragment. It is intended to be hidden
5 // from the user of Fragment, as an implementation detail. The interface
6 // of Fragment is intended to be used to access the data.
7 
8 //#include <cstddef>
9 #include <map>
10 #include "artdaq-core/Data/detail/RawFragmentHeader.hh"
11 #include "artdaq-core/Data/dictionarycontrol.hh"
12 #include "cetlib_except/exception.h"
13 
14 extern "C" {
15 #include <stdint.h>
16 }
17 
18 namespace artdaq {
19 namespace detail {
20 struct RawFragmentHeaderV1;
21 }
22 } // namespace artdaq
23 
33 {
37  typedef unsigned long long RawDataType;
38 
39 #if HIDE_FROM_ROOT
40  typedef uint16_t version_t;
41  typedef uint64_t sequence_id_t;
42  typedef uint8_t type_t;
43  typedef uint16_t fragment_id_t;
44  typedef uint8_t metadata_word_count_t;
45  typedef uint64_t timestamp_t;
46 
47  // define special values for type_t
48  static constexpr type_t INVALID_TYPE = 0;
49  static constexpr type_t FIRST_USER_TYPE = 1;
50  static constexpr type_t LAST_USER_TYPE = 224;
51  static constexpr type_t FIRST_SYSTEM_TYPE = 225;
52  static constexpr type_t LAST_SYSTEM_TYPE = 255;
55  static constexpr type_t DataFragmentType = FIRST_SYSTEM_TYPE + 1;
56  static constexpr type_t InitFragmentType = FIRST_SYSTEM_TYPE + 2;
60  static constexpr type_t EmptyFragmentType = FIRST_SYSTEM_TYPE + 6;
62 
67  static std::map<type_t, std::string> MakeSystemTypeMap()
68  {
69  return std::map<type_t, std::string>{
70  {type_t(DataFragmentType), "Data"},
71  {type_t(EmptyFragmentType), "Empty"},
72  {232, "Container"}};
73  }
74 
79  static std::map<type_t, std::string> MakeVerboseSystemTypeMap()
80  {
81  return std::map<type_t, std::string>{
82  {type_t(EndOfDataFragmentType), "EndOfData"},
83  {type_t(DataFragmentType), "Data"},
84  {type_t(InitFragmentType), "Init"},
85  {type_t(EndOfRunFragmentType), "EndOfRun"},
86  {type_t(EndOfSubrunFragmentType), "EndOfSubrun"},
87  {type_t(ShutdownFragmentType), "Shutdown"},
88  {type_t(EmptyFragmentType), "Empty"},
89  {type_t(ContainerFragmentType), "Container"}};
90  }
91 
97  static std::string SystemTypeToString(type_t type)
98  {
99  switch (type)
100  {
101  case INVALID_TYPE:
102  return "INVALID";
104  return "EndOfData";
105  case DataFragmentType:
106  return "Data";
107  case InitFragmentType:
108  return "Init";
110  return "EndOfRun";
112  return "EndOfSubrun";
114  return "Shutdown";
115  case EmptyFragmentType:
116  return "Empty";
118  return "Container";
119  }
120  return "Unknown";
121  }
122 
123  // Each of the following invalid values is chosen based on the
124  // size of the bitfield in which the corresponding data are
125  // encoded; if any of the sizes are changed, the corresponding
126  // values must be updated.
127  static const version_t InvalidVersion = 0xFFFF;
128  static const version_t CurrentVersion = 0x1;
129  static const sequence_id_t InvalidSequenceID = 0xFFFFFFFFFFFF;
130  static const fragment_id_t InvalidFragmentID = 0xFFFF;
131  static const timestamp_t InvalidTimestamp = 0xFFFFFFFFFFFFFFFF;
132 
137 
141 
142  // ****************************************************
143  // New fields MUST be added to the END of this list!!!
144  // ****************************************************
145 
150  static constexpr std::size_t num_words();
151 
157  void setUserType(uint8_t utype);
158 
164  void setSystemType(uint8_t stype);
165 
176  RawFragmentHeader upgrade() const;
177 
178 #endif /* HIDE_FROM_ROOT */
179 };
180 
181 #if HIDE_FROM_ROOT
182 inline constexpr std::size_t
184 {
185  return sizeof(detail::RawFragmentHeaderV1) / sizeof(RawDataType);
186 }
187 
188 // Compile-time check that the assumption made in num_words() above is
189 // actually true.
193  "sizeof(RawFragmentHeaderV1) is not an integer "
194  "multiple of sizeof(RawDataType)!");
195 
196 inline void
198 {
199  if (utype < FIRST_USER_TYPE || utype > LAST_USER_TYPE)
200  {
201  throw cet::exception("InvalidValue")
202  << "RawFragmentHeaderV1 user types must be in the range of "
203  << ((int)FIRST_USER_TYPE) << " to " << ((int)LAST_USER_TYPE)
204  << " (bad type is " << ((int)utype) << ").";
205  }
206  type = utype;
207 }
208 
209 inline void
211 {
212  if (stype < FIRST_SYSTEM_TYPE /*|| stype > LAST_SYSTEM_TYPE*/)
213  {
214  throw cet::exception("InvalidValue")
215  << "RawFragmentHeaderV1 system types must be in the range of "
216  << ((int)FIRST_SYSTEM_TYPE) << " to " << ((int)LAST_SYSTEM_TYPE);
217  }
218  type = stype;
219 }
220 
223 {
224  RawFragmentHeader output;
225  output.word_count = word_count;
227  output.type = type;
228  output.metadata_word_count = metadata_word_count;
229 
230  output.sequence_id = sequence_id;
231  output.fragment_id = fragment_id;
232  output.timestamp = timestamp;
233 
234  output.valid = true;
235  output.complete = true;
236 
238  output.atime_ns = time.tv_nsec;
239  output.atime_s = time.tv_sec;
240 
241  return output;
242 }
243 #endif
244 
245 #endif /* artdaq_core_Data_detail_RawFragmentHeaderV1_hh */
RawDataType metadata_word_count
The number of RawDataType words in the user-defined metadata.
static constexpr type_t ShutdownFragmentType
This Fragment indicates a system shutdown to art
RawDataType metadata_word_count
The number of RawDataType words in the user-defined metadata.
RawDataType word_count
number of RawDataType words in this Fragment
RawDataType type
The type of the fragment, either system or user-defined.
static constexpr std::size_t num_words()
Returns the number of RawDataType words present in the header.
uint64_t timestamp_t
timestamp field is 32 bits
static constexpr type_t FIRST_SYSTEM_TYPE
The first system type.
The RawFragmentHeader class contains the basic fields used by artdaq for routing Fragment objects thr...
static const fragment_id_t InvalidFragmentID
The fragment_id field is currently 16-bits.
static constexpr type_t EndOfSubrunFragmentType
This Fragment indicates the end of a subrun to art
RawDataType timestamp
The 64-bit timestamp field is the output of a user-defined clock used for building time-correlated ev...
RawDataType timestamp
The 64-bit timestamp field is the output of a user-defined clock used for building time-correlated ev...
RawDataType sequence_id
The 48-bit sequence_id uniquely identifies events within the artdaq system.
static constexpr type_t EndOfRunFragmentType
This Fragment indicates the end of a run to art
RawFragmentHeader upgrade() const
Upgrades the RawFragmentHeaderV1 to a RawFragmentHeader (Current version)
static constexpr type_t FIRST_USER_TYPE
The first user-accessible type.
RawDataType version
The version of the fragment.
RawDataType atime_s
Last access time of the Fragment, second part (measured from epoch)
static const sequence_id_t InvalidSequenceID
The sequence_id field is currently 48-bits.
RawDataType fragment_id
The fragment_id uniquely identifies a particular piece of hardware within the artdaq system...
static const timestamp_t InvalidTimestamp
The timestamp field is currently 64-bits.
uint16_t fragment_id_t
fragment_id field is 16 bits
static constexpr type_t LAST_SYSTEM_TYPE
The last system type.
unsigned long long RawDataType
The RawDataType (currently a 64-bit integer) is the basic unit of data representation within artdaq ...
static constexpr type_t InitFragmentType
This Fragment holds the necessary data for initializing art
struct timespec get_realtime_clock()
Get the current time of day as a pair of seconds and nanoseconds (from clock_gettime(CLOCK_REALTIME, ...) system call)
Definition: TimeUtils.cc:58
RawDataType valid
Flag for whether the Fragment has been transported correctly through the artdaq system.
RawDataType type
The type of the fragment, either system or user-defined.
static const version_t CurrentVersion
The CurrentVersion field should be incremented whenever the RawFragmentHeaderV1 changes.
static constexpr type_t DataFragmentType
This Fragment holds data. Used for RawEvent Fragments sent from the EventBuilder to the Aggregator...
RawDataType fragment_id
The fragment_id uniquely identifies a particular piece of hardware within the artdaq system...
uint64_t sequence_id_t
sequence_id field is 48 bits
static constexpr type_t INVALID_TYPE
Marks a Fragment as Invalid.
static std::map< type_t, std::string > MakeSystemTypeMap()
Returns a map of the most-commonly used system types.
static const version_t CurrentVersion
The CurrentVersion field should be incremented whenever the RawFragmentHeader changes.
uint8_t metadata_word_count_t
metadata_word_count field is 8 bits
static std::map< type_t, std::string > MakeVerboseSystemTypeMap()
Returns a map of all system types.
static constexpr type_t EmptyFragmentType
This Fragment contains no data and serves as a placeholder for when no data from a FragmentGenerator ...
static std::string SystemTypeToString(type_t type)
Print a system type&#39;s string name.
RawDataType atime_ns
Last access time of the Fragment, nanosecond part.
uint16_t version_t
version field is 16 bits
static constexpr type_t ContainerFragmentType
This Fragment is a ContainerFragment and analysis code should unpack it.
static constexpr type_t InvalidFragmentType
Marks a Fragment as Invalid.
The RawFragmentHeaderV1 class contains the basic fields used by artdaq for routing Fragment objects t...
static constexpr type_t EndOfDataFragmentType
This Fragment indicates the end of data to art
static const version_t InvalidVersion
The version field is currently 16-bits.
static constexpr type_t LAST_USER_TYPE
The last user-accessible type (types above this number are system types.
RawDataType word_count
number of RawDataType words in this Fragment
void setUserType(uint8_t utype)
Sets the type field to the specified user type.
RawDataType sequence_id
The 48-bit sequence_id uniquely identifies events within the artdaq system.
void setSystemType(uint8_t stype)
Sets the type field to the specified system type.
uint8_t type_t
type field is 8 bits
RawDataType version
The version of the fragment.
RawDataType complete
Flag for whether the Fragment completely represents an event for its hardware.