Line data    Source code

       1              : #include "artdaq/DAQdata/GenericFragmentSimulator.hh"
       2              : 
       3              : #include "cetlib_except/exception.h"
       4              : #include "fhiclcpp/ParameterSet.h"
       5              : 
       6              : #include <algorithm>
       7              : #include <functional>
       8              : #include <limits>
       9              : #include <memory>
      10              : 
      11            5 : artdaq::GenericFragmentSimulator::GenericFragmentSimulator(fhicl::ParameterSet const& ps)
      12            5 :     : content_selection_(static_cast<content_selector_t>(ps.get<size_t>("content_selection", 0)))
      13           10 :     , payload_size_spec_(ps.get<size_t>("payload_size", 10240))
      14           10 :     , want_random_payload_size_(ps.get<bool>("want_random_payload_size", false))
      15            5 :     , current_event_num_(0)
      16           10 :     , engine_(ps.get<int64_t>("random_seed", 314159))
      17           15 :     , payload_size_generator_(payload_size_spec_)
      18              : 
      19              : {
      20           10 :         fragment_ids_.resize(ps.get<size_t>("fragments_per_event", 5));
      21           10 :         auto current_id = ps.get<Fragment::fragment_id_t>("starting_fragment_id", 0);
      22            5 :         std::generate(fragment_ids_.begin(),
      23              :                       fragment_ids_.end(),
      24           25 :                       [&current_id]() { return current_id++; });
      25            5 : }
      26              : 
      27          410 : bool artdaq::GenericFragmentSimulator::getNext_(FragmentPtrs& frags)
      28              : {
      29          410 :         ++current_event_num_;
      30              :         // frags.reserve(frags.size() + fragment_ids_.size());
      31         2460 :         for (auto fragID : fragment_ids_)
      32              :         {
      33         2050 :                 frags.emplace_back();
      34              :                 bool result =
      35         2050 :                     getNext(current_event_num_, fragID, frags.back());
      36         2050 :                 if (!result) { return result; }
      37              :         }
      38          410 :         return true;
      39              : }
      40              : 
      41         2050 : bool artdaq::GenericFragmentSimulator::
      42              :     getNext(Fragment::sequence_id_t sequence_id,
      43              :             Fragment::fragment_id_t fragment_id,
      44              :             FragmentPtr& frag_ptr)
      45              : {
      46         2050 :         frag_ptr = std::make_unique<Fragment>(sequence_id, fragment_id);
      47         2050 :         size_t payload_size = generateFragmentSize_();
      48         2050 :         frag_ptr->resize(payload_size, 0);
      49         2050 :         frag_ptr->setSystemType(artdaq::Fragment::EmptyFragmentType);
      50         2050 :         switch (content_selection_)
      51              :         {
      52         2000 :                 case content_selector_t::EMPTY:
      53         2000 :                         break;  // values are already correct
      54            0 :                 case content_selector_t::FRAG_ID:
      55            0 :                         std::fill_n(frag_ptr->dataBegin(), payload_size, fragment_id);
      56            0 :                         break;
      57            0 :                 case content_selector_t::RANDOM:
      58            0 :                         std::generate_n(frag_ptr->dataBegin(),
      59              :                                         payload_size,
      60            0 :                                         [&]() -> int64_t {
      61            0 :                                                 return fragment_content_generator_(engine_);
      62              :                                         });
      63            0 :                         break;
      64           50 :                 case content_selector_t::DEAD_BEEF:
      65           50 :                         std::fill_n(frag_ptr->dataBegin(),
      66              :                                     payload_size,
      67           50 :                                     0xDEADBEEFDEADBEEF);
      68           50 :                         break;
      69            0 :                 default:
      70            0 :                         throw cet::exception("UnknownContentSelection")  // NOLINT(cert-err60-cpp)
      71              :                             << "Unknown content selection: "
      72            0 :                             << static_cast<uint8_t>(content_selection_);
      73              :         }
      74         2050 :         assert(frag_ptr != nullptr);
      75         2050 :         return true;
      76              : }
      77              : 
      78              : std::vector<artdaq::Fragment::fragment_id_t>
      79            2 : artdaq::GenericFragmentSimulator::
      80              :     fragmentIDs_()
      81              : {
      82            2 :         return fragment_ids_;
      83              : }
      84              : 
      85              : std::size_t
      86         2050 : artdaq::GenericFragmentSimulator::
      87              :     generateFragmentSize_()
      88              : {
      89         2050 :         return want_random_payload_size_ ? payload_size_generator_(engine_) : payload_size_spec_;
      90              : }