artdaq_core  v3_05_10
RawEvent.hh
1 #ifndef artdaq_core_Data_RawEvent_hh
2 #define artdaq_core_Data_RawEvent_hh
3 
4 #include "artdaq-core/Data/Fragment.hh"
5 #include "artdaq-core/Data/dictionarycontrol.hh"
6 
7 #include "cetlib_except/exception.h"
8 
9 #include <algorithm>
10 #include <iosfwd>
11 #include <memory>
12 
13 namespace artdaq {
17 namespace detail {
18 struct RawEventHeader;
19 }
20 
29 {
30  typedef uint32_t run_id_t;
31  typedef uint32_t subrun_id_t;
32  typedef uint32_t event_id_t;
34 
39  bool is_complete;
40 
49  subrun_id_t subrun,
50  event_id_t event,
51  sequence_id_t seq)
52  : run_id(run)
53  , subrun_id(subrun)
54  , event_id(event)
55  , sequence_id(seq)
56  , is_complete(false) {}
57 };
58 
66 class RawEvent
67 {
68 public:
73 
81  RawEvent(run_id_t run, subrun_id_t subrun, event_id_t event, sequence_id_t seq);
82 
87  explicit RawEvent(detail::RawEventHeader hdr);
88 
89 #if HIDE_FROM_ROOT
90 
99  void insertFragment(FragmentPtr&& pfrag);
100 
104  void markComplete();
105 
110  size_t numFragments() const;
111 
116  size_t wordCount() const;
117 
122  run_id_t runID() const;
123 
128  subrun_id_t subrunID() const;
129 
134  event_id_t eventID() const;
135 
140  sequence_id_t sequenceID() const;
141 
146  bool isComplete() const;
147 
152  void print(std::ostream& os) const;
153 
162  std::unique_ptr<Fragments> releaseProduct();
163 
168  void fragmentTypes(std::vector<Fragment::type_t>& type_list);
169 
182  std::unique_ptr<Fragments> releaseProduct(Fragment::type_t type);
183 
184 #endif
185 
186 private:
187  detail::RawEventHeader header_;
188  FragmentPtrs fragments_;
189 };
190 
191 typedef std::shared_ptr<RawEvent> RawEvent_ptr;
192 
194  : header_(run, subrun, event, seq)
195  , fragments_() {}
196 
198  : header_(hdr), fragments_()
199 {}
200 
201 #if HIDE_FROM_ROOT
203 {
204  if (pfrag == nullptr)
205  {
206  throw cet::exception("LogicError")
207  << "Attempt to insert a null FragmentPtr into a RawEvent detected.\n";
208  }
209  fragments_.emplace_back(std::move(pfrag));
210 }
211 
212 inline void RawEvent::markComplete() { header_.is_complete = true; }
213 
214 inline size_t RawEvent::numFragments() const
215 {
216  return fragments_.size();
217 }
218 
219 inline size_t RawEvent::wordCount() const
220 {
221  size_t sum = 0;
222  for (auto const& frag : fragments_) { sum += frag->size(); }
223  return sum;
224 }
225 
226 inline RawEvent::run_id_t RawEvent::runID() const { return header_.run_id; }
227 inline RawEvent::subrun_id_t RawEvent::subrunID() const { return header_.subrun_id; }
228 inline RawEvent::event_id_t RawEvent::eventID() const { return header_.event_id; }
229 inline RawEvent::sequence_id_t RawEvent::sequenceID() const { return header_.sequence_id; }
230 inline bool RawEvent::isComplete() const { return header_.is_complete; }
231 
232 inline std::unique_ptr<Fragments> RawEvent::releaseProduct()
233 {
234  std::unique_ptr<Fragments> result(new Fragments);
235  result->reserve(fragments_.size());
236  // 03/08/2016 ELF: Moving to range-for for STL compatibility
237  //for (size_t i = 0, sz = fragments_.size(); i < sz; ++i) {
238  for (auto& i : fragments_)
239  {
240  result->emplace_back(std::move(*i));
241  }
242  // It seems more hygenic to clear fragments_ rather than to leave
243  // it full of unique_ptrs to Fragments that have been plundered by
244  // the move.
245  fragments_.clear();
246  return result;
247 }
248 
249 inline void RawEvent::fragmentTypes(std::vector<Fragment::type_t>& type_list)
250 {
251  // 03/08/2016 ELF: Moving to range-for for STL compatibility
252  //for (size_t i = 0, sz = fragments_.size(); i < sz; ++i) {
253  for (auto& i : fragments_)
254  {
255  auto fragType = i->type(); // fragments_[i]->type();
256  if (std::find(type_list.begin(), type_list.end(), fragType) == type_list.end())
257  {
258  type_list.push_back(fragType);
259  }
260  }
261  //std::sort(type_list.begin(), type_list.end());
262  //std::unique(type_list.begin(), type_list.end());
263 }
264 
265 inline std::unique_ptr<Fragments>
267 {
268  std::unique_ptr<Fragments> result(new Fragments);
269  FragmentPtrs::iterator iter = fragments_.begin();
270  do
271  {
272  if ((*iter)->type() == fragment_type)
273  {
274  result->push_back(std::move(*(*iter)));
275  iter = fragments_.erase(iter);
276  }
277  else
278  {
279  ++iter;
280  }
281  } while (iter != fragments_.end());
282  return result;
283 }
284 
291 inline std::ostream& operator<<(std::ostream& os, RawEvent const& ev)
292 {
293  ev.print(os);
294  return os;
295 }
296 
297 #endif
298 } // namespace artdaq
299 
300 #endif /* artdaq_core_Data_RawEvent_hh */
std::unique_ptr< Fragment > FragmentPtr
A std::unique_ptr to a Fragment object.
Definition: Fragment.hh:54
std::unique_ptr< Fragments > releaseProduct()
Release all the Fragments from this RawEvent.
Definition: RawEvent.hh:232
detail::RawEventHeader::run_id_t run_id_t
Run numbers are 32 bits.
Definition: RawEvent.hh:69
event_id_t eventID() const
Retrieve the event number from the RawEventHeader.
Definition: RawEvent.hh:228
void fragmentTypes(std::vector< Fragment::type_t > &type_list)
Fills in a list of unique fragment types from this event.
Definition: RawEvent.hh:249
std::vector< Fragment > Fragments
A std::vector of Fragment objects.
Definition: Fragment.hh:42
subrun_id_t subrunID() const
Retrieve the subrun number from the RawEventHeader.
Definition: RawEvent.hh:227
RawEventHeader(run_id_t run, subrun_id_t subrun, event_id_t event, sequence_id_t seq)
Constructs the RawEventHeader struct with the given parameters.
Definition: RawEvent.hh:48
uint32_t event_id_t
Event numbers are 32 bits.
Definition: RawEvent.hh:32
detail::RawEventHeader::subrun_id_t subrun_id_t
Subrun numbers are 32 bits.
Definition: RawEvent.hh:70
sequence_id_t sequenceID() const
Retrieve the sequence id from the RawEventHeader.
Definition: RawEvent.hh:229
bool isComplete() const
Retrieve the value of the complete flag from the RawEventHeader.
Definition: RawEvent.hh:230
detail::RawEventHeader::sequence_id_t sequence_id_t
Field size should be the same as the Fragment::sequence_id field.
Definition: RawEvent.hh:72
detail::RawFragmentHeader::type_t type_t
typedef for type_t from RawFragmentHeader
Definition: Fragment.hh:137
size_t numFragments() const
Return the number of fragments this RawEvent contains.
Definition: RawEvent.hh:214
event_id_t event_id
Event number should be either sequence ID or Timestamp of component Fragments.
Definition: RawEvent.hh:37
detail::RawEventHeader::event_id_t event_id_t
Event numbers are 32 bits.
Definition: RawEvent.hh:71
uint32_t run_id_t
Run numbers are 32 bits.
Definition: RawEvent.hh:30
void print(std::ostream &os) const
Print summary information about this RawEvent to the given stream.
Definition: RawEvent.cc:5
RawEvent(run_id_t run, subrun_id_t subrun, event_id_t event, sequence_id_t seq)
Constructs a RawEvent with the given parameters.
Definition: RawEvent.hh:193
subrun_id_t subrun_id
Fragments don&#39;t know about subruns.
Definition: RawEvent.hh:36
run_id_t runID() const
Retrieve the run number from the RawEventHeader.
Definition: RawEvent.hh:226
std::ostream & operator<<(std::ostream &os, Fragment const &f)
Prints the given Fragment to the stream.
Definition: Fragment.hh:1279
Fragment::sequence_id_t sequence_id_t
Field size should be the same as the Fragment::sequence_id field.
Definition: RawEvent.hh:33
std::shared_ptr< RawEvent > RawEvent_ptr
A smart pointer to a RawEvent object.
Definition: GlobalQueue.hh:12
The header information used to identify key properties of the RawEvent object.
Definition: RawEvent.hh:28
std::list< FragmentPtr > FragmentPtrs
A std::list of FragmentPtrs.
Definition: Fragment.hh:59
void insertFragment(FragmentPtr &&pfrag)
Insert the given (pointer to a) Fragment into this RawEvent.
Definition: RawEvent.hh:202
run_id_t run_id
Fragments don&#39;t know about runs.
Definition: RawEvent.hh:35
size_t wordCount() const
Return the sum of the word counts of all fragments in this RawEvent.
Definition: RawEvent.hh:219
void markComplete()
Mark the event as complete.
Definition: RawEvent.hh:212
uint32_t subrun_id_t
Subrun numbers are 32 bits.
Definition: RawEvent.hh:31
detail::RawFragmentHeader::sequence_id_t sequence_id_t
typedef for sequence_id_t from RawFragmentHeader
Definition: Fragment.hh:138
bool is_complete
Does the event contain the expected number of Fragment objects?
Definition: RawEvent.hh:39
RawEvent is the artdaq view of a generic event, containing a header and zero or more Fragments...
Definition: RawEvent.hh:66
sequence_id_t sequence_id
RawEvent sequence_id should be the same as its component Fragment sequence_ids.
Definition: RawEvent.hh:38