Line data    Source code

       1              : #ifndef artdaq_ArtModules_ArtdaqEvent_hh
       2              : #define artdaq_ArtModules_ArtdaqEvent_hh
       3              : 
       4              : #include "artdaq-core/Data/RawEvent.hh"
       5              : 
       6              : #include <unordered_map>
       7              : 
       8              : /**
       9              :  * \brief An Artdaq Event, consisting of a header and a map of contained Fragments
      10              :  */
      11              : struct ArtdaqEvent
      12              : {
      13              :         std::shared_ptr<artdaq::detail::RawEventHeader> header;
      14              :         std::unordered_map<artdaq::Fragment::type_t, std::unique_ptr<artdaq::Fragments>> fragments;
      15              : 
      16            0 :         ArtdaqEvent()
      17            0 :             : header(nullptr), fragments() {}
      18              : 
      19            0 :         artdaq::Fragment::type_t FirstFragmentType() const
      20              :         {
      21            0 :                 if (fragments.empty()) return artdaq::Fragment::InvalidFragmentType;
      22            0 :                 return fragments.begin()->first;
      23              :         }
      24              : 
      25              :         size_t size() const
      26              :         {
      27              :                 size_t output = 0;
      28              : 
      29              :                 for (auto& type_pair : fragments)
      30              :                 {
      31              :                         output += type_pair.second->size();
      32              :                 }
      33              : 
      34              :                 return output;
      35              :         }
      36              : };
      37              : 
      38            0 : inline bool operator<(ArtdaqEvent const& l, ArtdaqEvent const& r)
      39              : {
      40            0 :         auto left = l.FirstFragmentType();
      41            0 :         auto right = r.FirstFragmentType();
      42              :         // Init Fragments are always first, EndOfData Fragments are always last
      43            0 :         if (left == artdaq::Fragment::InitFragmentType || right == artdaq::Fragment::InitFragmentType || left == artdaq::Fragment::EndOfDataFragmentType || right == artdaq::Fragment::EndOfDataFragmentType)
      44              :         {
      45            0 :                 if (left == right)
      46              :                 {
      47              :                         // Stable ordering
      48            0 :                         return l.header->sequence_id < r.header->sequence_id;
      49              :                 }
      50              :                 else
      51              :                 {
      52            0 :                         return left == artdaq::Fragment::InitFragmentType || right == artdaq::Fragment::EndOfDataFragmentType;
      53              :                 }
      54              :         }
      55            0 :         else if (l.header->run_id == r.header->run_id)
      56              :         {
      57              :                 // EndRun are last in run
      58            0 :                 if (left == artdaq::Fragment::EndOfRunFragmentType || right == artdaq::Fragment::EndOfRunFragmentType || left == artdaq::Fragment::RunDataFragmentType || right == artdaq::Fragment::RunDataFragmentType)
      59              :                 {
      60            0 :                         if (left == right)
      61              :                         {
      62              :                                 // Stable ordering
      63            0 :                                 return l.header->sequence_id < r.header->sequence_id;
      64              :                         }
      65              :                         else
      66              :                         {
      67            0 :                                 return right == artdaq::Fragment::EndOfRunFragmentType || right == artdaq::Fragment::RunDataFragmentType;
      68              :                         }
      69              :                 }
      70              : 
      71            0 :                 if (l.header->subrun_id == r.header->subrun_id)
      72              :                 {
      73              :                         // EndSubrun are last within a subrun
      74            0 :                         if (left == artdaq::Fragment::EndOfSubrunFragmentType || right == artdaq::Fragment::EndOfSubrunFragmentType || left == artdaq::Fragment::SubrunDataFragmentType || right == artdaq::Fragment::SubrunDataFragmentType)
      75              :                         {
      76            0 :                                 if (left == right)
      77              :                                 {
      78              :                                         // Stable ordering
      79            0 :                                         return l.header->sequence_id < r.header->sequence_id;
      80              :                                 }
      81              :                                 else
      82              :                                 {
      83            0 :                                         return right == artdaq::Fragment::EndOfSubrunFragmentType || right == artdaq::Fragment::SubrunDataFragmentType;
      84              :                                 }
      85              :                         }
      86              : 
      87              :                         // Order by sequence ID if not a recognized system broadcast
      88            0 :                         return l.header->sequence_id < r.header->sequence_id;
      89              :                 }
      90              :                 else
      91              :                 {
      92            0 :                         return l.header->subrun_id < r.header->subrun_id;
      93              :                 }
      94              :         }
      95              :         else
      96              :         {
      97            0 :                 return l.header->run_id < r.header->run_id;
      98              :         }
      99              : }
     100              : 
     101            0 : inline bool operator<(std::shared_ptr<ArtdaqEvent> const& l, std::shared_ptr<ArtdaqEvent> const& r)
     102              : {
     103            0 :         return *l < *r;
     104              : }
     105              : 
     106              : #endif /* artdaq_ArtModules_ArtdaqEvent_hh */
     107              : 
     108              : // Local Variables:
     109              : // mode: c++
     110              : // End: