artdaq_core  v3_05_10
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 
237  // ELF 10/1/19: Due to how many times upgrade() gets called during an analysis process, better to just zero these fields
238  // auto time = artdaq::TimeUtils::get_realtime_clock();
239  // output.atime_ns = time.tv_nsec;
240  // output.atime_s = time.tv_sec;
241  output.atime_ns = 0;
242  output.atime_s = 0;
243 
244  return output;
245 }
246 #endif
247 
248 #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
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.