Line data    Source code

       1              : #include "TRACE/tracemf.h"
       2              : #define TRACE_NAME "FragmentSniffer"
       3              : 
       4              : #include <memory>
       5              : #include <string>
       6              : 
       7              : #include "art/Framework/Core/EDAnalyzer.h"
       8              : #include "art/Framework/Core/ModuleMacros.h"
       9              : #include "art/Framework/Principal/Event.h"
      10              : #include "art/Framework/Principal/Handle.h"
      11              : #include "art/Framework/Principal/Run.h"
      12              : #include "art/Framework/Principal/SubRun.h"
      13              : #include "canvas/Persistency/Provenance/BranchType.h"
      14              : #include "fhiclcpp/ParameterSet.h"
      15              : 
      16              : #include "artdaq-core/Data/Fragment.hh"
      17              : #include "artdaq/DAQdata/Globals.hh"
      18              : 
      19              : namespace artdaq {
      20              : /**
      21              :  * \brief This art::EDAnalyzer plugin tries to get Fragments from each event, asserting that the correct number of Fragments were present
      22              :  */
      23              : class FragmentSniffer : public art::EDAnalyzer
      24              : {
      25              : public:
      26              :         /**
      27              :          * \brief FragmentSniffer Constructor
      28              :          * \param p ParameterSet used to configure FragmentSniffer
      29              :          *
      30              :          * \verbatim
      31              :          * FragmentSniffer accepts the following Parameters:
      32              :          * "raw_label" (Default: "daq"): Label under which Fragments are stored
      33              :          * "product_instance_name" (REQUIRED): Instance name under which Fragments are stored (Should be Fragment type name)
      34              :          * "num_frags_per_event" (REQUIRED): Expected number of Fragments in each event
      35              :          * "num_events_expected" (Default: 0): Expected number of events in the job. If 0, will not perform end-of-job test
      36              :          * \endverbatim
      37              :          */
      38              :         explicit FragmentSniffer(fhicl::ParameterSet const& p);
      39              : 
      40              :         /**
      41              :          * \brief Default destructor
      42              :          */
      43            0 :         ~FragmentSniffer() override = default;
      44              : 
      45              :         /**
      46              :          * \brief Called for each event. Asserts that Fragment objects are present in the event and that the correct number of Fragments were found
      47              :          * \param e Event to analyze
      48              :          */
      49              :         void analyze(art::Event const& e) override;
      50              : 
      51              :         /**
      52              :          * \brief Called at the end of the job. Asserts that the number of events processed was equal to the expected number
      53              :          */
      54              :         void endJob() override;
      55              : 
      56              : private:
      57              :         FragmentSniffer(FragmentSniffer const&) = delete;
      58              :         FragmentSniffer(FragmentSniffer&&) = delete;
      59              :         FragmentSniffer& operator=(FragmentSniffer const&) = delete;
      60              :         FragmentSniffer& operator=(FragmentSniffer&&) = delete;
      61              : 
      62              :         std::string raw_label_;
      63              :         std::string product_instance_name_;
      64              :         std::size_t num_frags_per_event_;
      65              :         std::size_t num_events_expected_;
      66              :         std::size_t num_events_processed_;
      67              : };
      68              : 
      69            0 : FragmentSniffer::FragmentSniffer(fhicl::ParameterSet const& p)
      70              :     : art::EDAnalyzer(p)
      71            0 :     , raw_label_(p.get<std::string>("raw_label", "daq"))
      72            0 :     , product_instance_name_(p.get<std::string>("product_instance_name"))
      73            0 :     , num_frags_per_event_(p.get<size_t>("num_frags_per_event"))
      74            0 :     , num_events_expected_(p.get<size_t>("num_events_expected", 0))
      75            0 :     , num_events_processed_() {}
      76              : 
      77            0 : void FragmentSniffer::analyze(art::Event const& e)
      78              : {
      79            0 :         TLOG(TLVL_DEBUG) << "Analyze called for event " << e.event();
      80            0 :         art::Handle<Fragments> handle;
      81            0 :         e.getByLabel(raw_label_, product_instance_name_, handle);
      82            0 :         assert(!handle->empty() && "getByLabel returned empty handle");
      83            0 :         assert(handle->size() == num_frags_per_event_);
      84            0 :         ++num_events_processed_;
      85            0 :         TLOG(TLVL_DEBUG) << "End of FragmentSniffer::analyze";
      86            0 : }
      87              : 
      88            0 : void FragmentSniffer::endJob()
      89              : {
      90            0 :         TLOG(TLVL_INFO) << "events processed: "
      91            0 :                         << num_events_processed_
      92            0 :                         << "\nevents expected:  "
      93            0 :                         << num_events_expected_;
      94            0 :         if (num_events_expected_ > 0) { assert(num_events_processed_ == num_events_expected_); }
      95            0 : }
      96              : 
      97            0 : DEFINE_ART_MODULE(FragmentSniffer)  // NOLINT(performance-unnecessary-value-param)
      98              : }  // namespace artdaq