artdaq_core  v3_05_00
RawEvent.hh
1 #ifndef artdaq_core_Data_RawEvent_hh
2 #define artdaq_core_Data_RawEvent_hh
3 
4 #include "artdaq-core/Data/dictionarycontrol.hh"
5 #include "artdaq-core/Data/Fragment.hh"
6 
7 #include "cetlib_except/exception.h"
8 
9 #include <iosfwd>
10 #include <memory>
11 #include <algorithm>
12 
13 namespace artdaq
14 {
18  namespace detail
19  {
20  struct RawEventHeader;
21  }
22 
31  {
32  typedef uint32_t run_id_t;
33  typedef uint32_t subrun_id_t;
34  typedef uint32_t event_id_t;
36 
41  bool is_complete;
42 
51  subrun_id_t subrun,
52  event_id_t event,
53  sequence_id_t seq) :
54  run_id(run)
55  , subrun_id(subrun)
56  , event_id(event)
57  , sequence_id(seq)
58  , is_complete(false) { }
59  };
60 
61 
69  class RawEvent
70  {
71  public:
76 
84  RawEvent(run_id_t run, subrun_id_t subrun, event_id_t event, sequence_id_t seq);
85 
90  explicit RawEvent(detail::RawEventHeader hdr);
91 
92 #if HIDE_FROM_ROOT
93 
102  void insertFragment(FragmentPtr&& pfrag);
103 
107  void markComplete();
108 
113  size_t numFragments() const;
114 
119  size_t wordCount() const;
120 
125  run_id_t runID() const;
126 
131  subrun_id_t subrunID() const;
132 
137  event_id_t eventID() const;
138 
143  sequence_id_t sequenceID() const;
144 
149  bool isComplete() const;
150 
155  void print(std::ostream& os) const;
156 
165  std::unique_ptr<Fragments> releaseProduct();
166 
171  void fragmentTypes(std::vector<Fragment::type_t>& type_list);
172 
185  std::unique_ptr<Fragments> releaseProduct(Fragment::type_t type);
186 
187 #endif
188 
189  private:
190  detail::RawEventHeader header_;
191  FragmentPtrs fragments_;
192  };
193 
194  typedef std::shared_ptr<RawEvent> RawEvent_ptr;
195 
196  inline
198  header_(run, subrun, event, seq)
199  , fragments_() { }
200 
201  inline RawEvent::RawEvent(detail::RawEventHeader hdr) : header_(hdr), fragments_()
202  {}
203 
204 #if HIDE_FROM_ROOT
205  inline
207  {
208  if (pfrag == nullptr)
209  {
210  throw cet::exception("LogicError")
211  << "Attempt to insert a null FragmentPtr into a RawEvent detected.\n";
212  }
213  fragments_.emplace_back(std::move(pfrag));
214  }
215 
216  inline void RawEvent::markComplete() { header_.is_complete = true; }
217 
218  inline
219  size_t RawEvent::numFragments() const
220  {
221  return fragments_.size();
222  }
223 
224  inline
225  size_t RawEvent::wordCount() const
226  {
227  size_t sum = 0;
228  for (auto const& frag : fragments_) { sum += frag->size(); }
229  return sum;
230  }
231 
232  inline RawEvent::run_id_t RawEvent::runID() const { return header_.run_id; }
233  inline RawEvent::subrun_id_t RawEvent::subrunID() const { return header_.subrun_id; }
234  inline RawEvent::event_id_t RawEvent::eventID() const { return header_.event_id; }
235  inline RawEvent::sequence_id_t RawEvent::sequenceID() const { return header_.sequence_id; }
236  inline bool RawEvent::isComplete() const { return header_.is_complete; }
237 
238  inline
239  std::unique_ptr<Fragments> RawEvent::releaseProduct()
240  {
241  std::unique_ptr<Fragments> result(new Fragments);
242  result->reserve(fragments_.size());
243  // 03/08/2016 ELF: Moving to range-for for STL compatibility
244  //for (size_t i = 0, sz = fragments_.size(); i < sz; ++i) {
245  for (auto& i : fragments_)
246  {
247  result->emplace_back(std::move(*i));
248  }
249  // It seems more hygenic to clear fragments_ rather than to leave
250  // it full of unique_ptrs to Fragments that have been plundered by
251  // the move.
252  fragments_.clear();
253  return result;
254  }
255 
256  inline
257  void RawEvent::fragmentTypes(std::vector<Fragment::type_t>& type_list)
258  {
259  // 03/08/2016 ELF: Moving to range-for for STL compatibility
260  //for (size_t i = 0, sz = fragments_.size(); i < sz; ++i) {
261  for (auto& i : fragments_)
262  {
263  auto fragType = i->type(); // fragments_[i]->type();
264  if (std::find(type_list.begin(), type_list.end(), fragType) == type_list.end())
265  {
266  type_list.push_back(fragType);
267  }
268  }
269  //std::sort(type_list.begin(), type_list.end());
270  //std::unique(type_list.begin(), type_list.end());
271  }
272 
273  inline
274  std::unique_ptr<Fragments>
276  {
277  std::unique_ptr<Fragments> result(new Fragments);
278  FragmentPtrs::iterator iter = fragments_.begin();
279  do
280  {
281  if ((*iter)->type() == fragment_type)
282  {
283  result->push_back(std::move(*(*iter)));
284  iter = fragments_.erase(iter);
285  }
286  else
287  {
288  ++iter;
289  }
290  }
291  while (iter != fragments_.end());
292  return result;
293  }
294 
301  inline
302  std::ostream& operator<<(std::ostream& os, RawEvent const& ev)
303  {
304  ev.print(os);
305  return os;
306  }
307 
308 #endif
309 }
310 
311 #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:239
detail::RawEventHeader::run_id_t run_id_t
Run numbers are 32 bits.
Definition: RawEvent.hh:72
event_id_t eventID() const
Retrieve the event number from the RawEventHeader.
Definition: RawEvent.hh:234
void fragmentTypes(std::vector< Fragment::type_t > &type_list)
Fills in a list of unique fragment types from this event.
Definition: RawEvent.hh:257
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:233
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:50
uint32_t event_id_t
Event numbers are 32 bits.
Definition: RawEvent.hh:34
detail::RawEventHeader::subrun_id_t subrun_id_t
Subrun numbers are 32 bits.
Definition: RawEvent.hh:73
sequence_id_t sequenceID() const
Retrieve the sequence id from the RawEventHeader.
Definition: RawEvent.hh:235
bool isComplete() const
Retrieve the value of the complete flag from the RawEventHeader.
Definition: RawEvent.hh:236
detail::RawEventHeader::sequence_id_t sequence_id_t
Field size should be the same as the Fragment::sequence_id field.
Definition: RawEvent.hh:75
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:219
event_id_t event_id
Event number should be either sequence ID or Timestamp of component Fragments.
Definition: RawEvent.hh:39
detail::RawEventHeader::event_id_t event_id_t
Event numbers are 32 bits.
Definition: RawEvent.hh:74
uint32_t run_id_t
Run numbers are 32 bits.
Definition: RawEvent.hh:32
void print(std::ostream &os) const
Print summary information about this RawEvent to the given stream.
Definition: RawEvent.cc:6
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:197
subrun_id_t subrun_id
Fragments don&#39;t know about subruns.
Definition: RawEvent.hh:38
run_id_t runID() const
Retrieve the run number from the RawEventHeader.
Definition: RawEvent.hh:232
std::ostream & operator<<(std::ostream &os, Fragment const &f)
Prints the given Fragment to the stream.
Definition: Fragment.hh:1277
Fragment::sequence_id_t sequence_id_t
Field size should be the same as the Fragment::sequence_id field.
Definition: RawEvent.hh:35
std::shared_ptr< RawEvent > RawEvent_ptr
A smart pointer to a RawEvent object.
Definition: GlobalQueue.hh:13
The header information used to identify key properties of the RawEvent object.
Definition: RawEvent.hh:30
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:206
run_id_t run_id
Fragments don&#39;t know about runs.
Definition: RawEvent.hh:37
size_t wordCount() const
Return the sum of the word counts of all fragments in this RawEvent.
Definition: RawEvent.hh:225
void markComplete()
Mark the event as complete.
Definition: RawEvent.hh:216
uint32_t subrun_id_t
Subrun numbers are 32 bits.
Definition: RawEvent.hh:33
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:41
RawEvent is the artdaq view of a generic event, containing a header and zero or more Fragments...
Definition: RawEvent.hh:69
sequence_id_t sequence_id
RawEvent sequence_id should be the same as its component Fragment sequence_ids.
Definition: RawEvent.hh:40