Inheritance diagram for dune::FelixIntegrityTest:

Classes
struct	ErrorMetrics

Public Member Functions
	FelixIntegrityTest (fhicl::ParameterSet const &p)

	FelixIntegrityTest (FelixIntegrityTest const &)=delete

	FelixIntegrityTest (FelixIntegrityTest &&)=delete

FelixIntegrityTest &	operator= (FelixIntegrityTest const &)=delete

FelixIntegrityTest &	operator= (FelixIntegrityTest &&)=delete

void	analyze (const art::Event &evt) override

void	beginJob () override

void	endJob () override

Public Member Functions inherited from art::EDAnalyzer
	EDAnalyzer (fhicl::ParameterSet const &pset)

template<typename Config >
	EDAnalyzer (Table< Config > const &config)

std::string	workerType () const

Public Member Functions inherited from art::detail::Analyzer
virtual	~Analyzer () noexcept

	Analyzer (fhicl::ParameterSet const &pset)

template<typename Config >
	Analyzer (Table< Config > const &config)

void	doBeginJob (SharedResources const &resources)

void	doEndJob ()

void	doRespondToOpenInputFile (FileBlock const &fb)

void	doRespondToCloseInputFile (FileBlock const &fb)

void	doRespondToOpenOutputFiles (FileBlock const &fb)

void	doRespondToCloseOutputFiles (FileBlock const &fb)

bool	doBeginRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doEndRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)

Public Member Functions inherited from art::Observer
	~Observer () noexcept

	Observer (Observer const &)=delete

	Observer (Observer &&)=delete

Observer &	operator= (Observer const &)=delete

Observer &	operator= (Observer &&)=delete

void	registerProducts (ProductDescriptions &, ModuleDescription const &)

void	fillDescriptions (ModuleDescription const &)

fhicl::ParameterSetID	selectorConfig () const

Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept

	ModuleBase ()

ModuleDescription const &	moduleDescription () const

void	setModuleDescription (ModuleDescription const &)

std::array< std::vector< ProductInfo >, NumBranchTypes > const &	getConsumables () const

void	sortConsumables (std::string const &current_process_name)

template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)

template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Private Member Functions
ErrorMetrics	_process (const artdaq::Fragment &frag)

Private Attributes
std::string	_input_label

bool	_expect_container_fragments

dune::FelixFragmentBase::Metadata	run_meta = {0xcba}

const uint64_t	timestamp_increase = 25

const uint16_t	convert_count_increase = 1

std::vector< ErrorMetrics >	test_results

unsigned	n_good_frags = 0

unsigned	n_bad_frags = 0

Additional Inherited Members
Public Types inherited from art::EDAnalyzer
using	WorkerType = WorkerT< EDAnalyzer >

using	ModuleType = EDAnalyzer

Protected Member Functions inherited from art::Observer
std::string const &	processName () const

bool	wantAllEvents () const noexcept

bool	wantEvent (ScheduleID id, Event const &e) const

Handle< TriggerResults >	getTriggerResults (Event const &e) const

	Observer (fhicl::ParameterSet const &config)

	Observer (std::vector< std::string > const &select_paths, std::vector< std::string > const &reject_paths, fhicl::ParameterSet const &config)

Protected Member Functions inherited from art::ModuleBase
ConsumesCollector &	consumesCollector ()

template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)

template<typename T , BranchType = InEvent>
void	consumesMany ()

template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)

template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

Detailed Description

Definition at line 35 of file FelixIntegrityTest_module.cc.

Constructor & Destructor Documentation

dune::FelixIntegrityTest::FelixIntegrityTest ( fhicl::ParameterSet const & p )

explicit

Definition at line 111 of file FelixIntegrityTest_module.cc.

   : EDAnalyzer(pset),
     _input_label(pset.get<std::string>("RawDataLabel")),
     _expect_container_fragments(pset.get<bool>("ExpectContainerFragments", true)) {}

dune::FelixIntegrityTest::FelixIntegrityTest ( FelixIntegrityTest const & )

delete

dune::FelixIntegrityTest::FelixIntegrityTest ( FelixIntegrityTest && )

delete

Member Function Documentation

dune::FelixIntegrityTest::ErrorMetrics dune::FelixIntegrityTest::_process ( const artdaq::Fragment & frag )

private

Definition at line 240 of file FelixIntegrityTest_module.cc.

 {
   // Load overlay class
   dune::FelixFragment flxfrag(frag);
 
   std::cout
       << "-------------------- Testing fragment -------------------" << '\n'
       << "SequenceID: " << frag.sequenceID()
       << "  fragmentID: " << frag.fragmentID()
       << "  fragmentType: " << (unsigned)frag.type()
       << "  Timestamp: " << frag.timestamp()
       << "  Crate number: " << (int)flxfrag.crate_no()
       << "  Slot number: " << (int)flxfrag.slot_no()
       << "  Fiber number: " << (int)flxfrag.fiber_no() << "\n\n";
 
   // Metadata tests
   const dune::FelixFragmentBase::Metadata* meta = frag.metadata<dune::FelixFragmentBase::Metadata>();
   bool meta_failed = false;
   // Record the first metadata, compare otherwise
   if(run_meta.control_word == 0xcba) {
     run_meta = *meta;
   } else {
     meta_failed |= meta->control_word != run_meta.control_word
                 || meta->version != run_meta.version
                 || meta->reordered != run_meta.reordered
                 || meta->compressed != run_meta.compressed
                 || meta->num_frames != run_meta.num_frames
                 || meta->offset_frames != run_meta.offset_frames
                 || meta->window_frames != run_meta.window_frames;
     if(meta_failed) {
       std::cout
           << "Metadata error." << '\n'
           << "  This fragment's metadata: " << '\n'
           << "      Control word: " << meta->control_word
           << "      Version: " << meta->version
           << "      Reordered: " << meta->reordered
           << "      Compressed: " << meta->compressed
           << "      Number of frames: " << meta->num_frames
           << "      Offset frames: " << meta->offset_frames
           << "      Window frames: " << meta->window_frames << '\n'
           << "  Expected metadata: " << '\n'
           << "      Control word: " << run_meta.control_word
           << "      Version: " << run_meta.version
           << "      Reordered: " << run_meta.reordered
           << "      Compressed: " << run_meta.compressed
           << "      Number of frames: " << run_meta.num_frames
           << "      Offset frames: " << run_meta.offset_frames
           << "      Window frames: " << run_meta.window_frames << "\n\n";
     } else {
       std::cout
           << "Metadata test successful." << "\n\n";
     }
   }
 
   // Timestamp tests
   bool timestamp_failed = false;
   // Compare to metadata: first frame must be within 25 counts of the fragment timestamp
   if(frag.timestamp() - meta->offset_frames*timestamp_increase - flxfrag.timestamp(0) >= timestamp_increase) {
     timestamp_failed = true;
     std::cout
         << "First timestamp matching error." << '\n'
         << "  This fragment's timestamp: " << frag.timestamp()
         << "  First frame's timestamp: " << flxfrag.timestamp(0)
         << "  Expected offset (-24 or less): " << meta->offset_frames*timestamp_increase
         << "  Offset: " << frag.timestamp() - flxfrag.timestamp(0) << "\n\n";
   }
   // Make sure the correct number of frames is contained when compared to the metadata
   if(flxfrag.total_frames() != meta->window_frames) {
     timestamp_failed = true;
     std::cout
         << "Trigger window error." << '\n'
         << "  This fragment's expected number of frames: " << meta->window_frames
         << "  Number of frames available: " << flxfrag.timestamp(0) << "\n\n";
   }
   // Go through all timestamps and check their increase
   for(unsigned fi = 1; fi < flxfrag.total_frames(); ++fi) {
     if(flxfrag.timestamp(fi) - flxfrag.timestamp(fi-1) != timestamp_increase) {
       timestamp_failed = true;
       std::cout
           << "Timestamp increase error." << '\n'
           << "  Timestamp of frame " << fi - 1 << ": " << flxfrag.timestamp(fi-1)
           << "  Timestamp of frame " << fi << ": " << flxfrag.timestamp(fi)
           << "  Difference: " << flxfrag.timestamp(fi) - flxfrag.timestamp(fi-1) << "\n\n";
       break;
     }
   }
   if(!timestamp_failed) {
     std::cout
         << "Timestamp test successful." << "\n\n";
   }
 
   // Convert count test
   bool convert_count_failed = false;
   // Check the increase of all convert counts between frames
   for(unsigned fi = 1; fi < flxfrag.total_frames(); ++fi) {
     // The first two counts and last two counts need to be identical
     for(int bi = 0; bi < 2; ++bi) {
       if(flxfrag.coldata_convert_count(fi, 2*bi) != flxfrag.coldata_convert_count(fi, 2*bi + 1)
          || (flxfrag.coldata_convert_count(fi, bi) - flxfrag.coldata_convert_count(fi - 1, bi)
              != convert_count_increase
              && flxfrag.coldata_convert_count(fi, bi) - flxfrag.coldata_convert_count(fi - 1, bi)
              != convert_count_increase - (1<<16))) {
         convert_count_failed = true;
         std::cout
             << "COLDATA convert count increase error in frame " << fi << ".\n"
             << "  Count 1 of frame " << fi - 1 << ": " << flxfrag.coldata_convert_count(fi-1, 0)
             << "  Count 2 of frame " << fi - 1 << ": " << flxfrag.coldata_convert_count(fi-1, 1)
             << "  Count 3 of frame " << fi - 1 << ": " << flxfrag.coldata_convert_count(fi-1, 2)
             << "  Count 4 of frame " << fi - 1 << ": " << flxfrag.coldata_convert_count(fi-1, 3) << '\n'
             << "  Count 1 of frame " << fi << ": " << flxfrag.coldata_convert_count(fi, 0)
             << "  Count 2 of frame " << fi << ": " << flxfrag.coldata_convert_count(fi, 1)
             << "  Count 3 of frame " << fi << ": " << flxfrag.coldata_convert_count(fi, 2)
             << "  Count 4 of frame " << fi << ": " << flxfrag.coldata_convert_count(fi, 3) << '\n'
             << "  Difference: "
             << flxfrag.coldata_convert_count(fi, 0) - flxfrag.coldata_convert_count(fi-1, 0) << "\n\n";
         break;
       }
     }
     if(convert_count_failed) break;
   }
   if(!convert_count_failed) {
     std::cout
         << "COLDATA convert count test successful." << "\n\n";
   }
 
   // Frame error fields test
   bool error_field_failed = false;
   // Check all error fields in all frames without distinction for now
   // // TODO: Look into what errors are relevant!
   // for(unsigned fi = 0; fi < 0/*flxfrag.total_frames()*/; ++fi) {
   //   error_field_failed |= flxfrag.mm(fi) || flxfrag.oos(fi) || flxfrag.wib_errors(fi);
   //   for(unsigned bi = 0; bi < 4; ++bi) {
   //     error_field_failed |= flxfrag.s1_error(fi, bi) || flxfrag.s2_error(fi, bi)
   //                           || flxfrag.error_register(fi, bi);
   //   }
   //
   //   if(error_field_failed) {
   //     std::cout
   //         << "One or more error fields set in frame " << fi << ".\n"
   //         << "  Mismatch: " << (int)flxfrag.mm(fi)
   //         << "  Out of sync: " << (int)flxfrag.oos(fi)
   //         << "  WIB errors: " << (int)flxfrag.wib_errors(fi) << '\n';
   //     for(unsigned bi = 0; bi < 4; ++bi) {
   //       std::cout
   //           << "  Block " << bi+1 << ":\n"
   //           << "    Stream 1 error: " << (int)flxfrag.s1_error(fi, bi)
   //           << "    Stream 2 error: " << (int)flxfrag.s2_error(fi, bi)
   //           << "    Error register: " << (int)flxfrag.error_register(fi, bi) << '\n';
   //     }
   //     std::cout << '\n';
   //     break;
   //   }
   // }
 
   //Output error metrics
   ErrorMetrics outem;
   outem.sequenceID = frag.sequenceID();
   outem.fragmentID = frag.fragmentID();
   outem.type = frag.type();
   outem.timestamp = frag.timestamp();
   outem.crate_no = flxfrag.crate_no();
   outem.slot_no = flxfrag.slot_no();
   outem.fiber_no = flxfrag.fiber_no();
   outem.meta = *meta;
   outem.meta_err = meta_failed;
   outem.timestamp_err = timestamp_failed;
   outem.convert_count_err = convert_count_failed;
   outem.error_fields_set = error_field_failed;
 
   outem.bad = timestamp_failed || convert_count_failed || error_field_failed;
 
   return outem;
 }

void dune::FelixIntegrityTest::analyze ( const art::Event & evt )

override

Definition at line 119 of file FelixIntegrityTest_module.cc.

                                                         {
   std::cout << "-------------------- FELIX Integrity Test -------------------";
 
   if (_expect_container_fragments) {
     art::InputTag itag1(_input_label, "ContainerFELIX");
     auto cont_frags = evt.getHandle<artdaq::Fragments>(itag1);
     art::EventNumber_t eventNumber = evt.event();
     // Check if there is Timing data in this event
     // Don't crash code if not present, just don't save anything
     try { cont_frags->size(); }
     catch(std::exception const&) {
       std::cout << "WARNING: Container FELIX data not found in event " << eventNumber << std::endl;
       return;
     }
     //Check that the data is valid
     if (!cont_frags){
       MF_LOG_ERROR("FelixIntegrityTest")
           << "Run: " << evt.run()
           << ", SubRun: " << evt.subRun()
           << ", Event: " << evt.event()
           << " Container Fragment data invalid";
     }
 
     for (auto const& cont : *cont_frags)
     {
       artdaq::ContainerFragment cont_frag(cont);
       for (size_t ii = 0; ii < cont_frag.block_count(); ++ii)
       {
         const ErrorMetrics this_err = _process(*cont_frag[ii]);
         test_results.push_back(this_err);
         this_err.bad? ++n_bad_frags : ++n_good_frags;
       }
     }
   }
   else
   {
     art::InputTag itag2(_input_label, "FELIX");
     auto frags = evt.getHandle<artdaq::Fragments>(itag2);
     // Check if there is Timing data in this event
     // Don't crash code if not present, just don't save anything
     art::EventNumber_t eventNumber = evt.event();
     try { frags->size(); }
     catch(std::exception const&) {
       std::cout << "WARNING: Raw FELIX data not found in event " << eventNumber << std::endl;
       return;
     }
 
     //Check that the data is valid
     if (!frags){
       MF_LOG_ERROR("FelixIntegrityTest")
           << "Run: " << evt.run()
           << ", SubRun: " << evt.subRun()
           << ", Event: " << evt.event()
           << " Fragment data invalid";
     }
 
     for(auto const& frag: *frags)
     {
       const ErrorMetrics this_err = _process(frag);
       test_results.push_back(this_err);
       this_err.bad? ++n_bad_frags : ++n_good_frags;
     }
   }
 }

void dune::FelixIntegrityTest::beginJob ( )

overridevirtual

Reimplemented from art::EDAnalyzer.

Definition at line 116 of file FelixIntegrityTest_module.cc.

116 {

117 }

void dune::FelixIntegrityTest::endJob ( )

overridevirtual

Reimplemented from art::EDAnalyzer.

Definition at line 184 of file FelixIntegrityTest_module.cc.

                                     {
   const unsigned long n_frags = n_bad_frags + n_good_frags;
   std::cout
       << "\nProcessed " << n_bad_frags+n_good_frags
       << " FELIX Fragments.\nFound " << n_good_frags
       << " good fragments. Success rate: "
       << (double)n_good_frags/n_frags << "/1.\n\n";
 
   // Create structs for easier looping.
   struct Location {
     uint64_t crate_no, slot_no, fiber_no;
     bool operator<(const Location& b) const {
       if(crate_no == b.crate_no && slot_no == b.slot_no) {
         return fiber_no < b.fiber_no;
       } else if(crate_no == b.crate_no) {
         return slot_no < b.slot_no;
       }
       return crate_no < b.crate_no;
     }
   };
   struct Errors {
     unsigned long meta_err, timestamp_err, convert_count_err, error_fields_set;
     void operator+=(const Errors& other) {
       meta_err += other.meta_err;
       timestamp_err += other.timestamp_err;
       convert_count_err += other.convert_count_err;
       error_fields_set += other.error_fields_set;
     }
   };
   // Loop over collected error metrics to find their origin
   std::map<Location, Errors> errMap;
   for(const ErrorMetrics& errm : test_results) {
     Location loc = {errm.crate_no, errm.slot_no, errm.fiber_no};
     Errors err = {(unsigned long)errm.meta_err, (unsigned long)errm.timestamp_err,
                   (unsigned long)errm.convert_count_err, (unsigned long)errm.error_fields_set};
     errMap[loc] += err;
   }
   // Print the error rate in a nice table
   std::cout << "Error rates\n";
   std::cout << "Crate:Slot:Fiber | Metadata error | Timestamp error | Convert count error | Error fields set\n"
             << "--------------------------------------------------------------------------------------------\n";
   for(const std::pair<Location, Errors>& p : errMap) {
     std::cout << std::left << std::setw(16) << std::to_string(p.first.crate_no) + ":" + std::to_string(p.first.slot_no) + ":" + std::to_string(p.first.fiber_no) << " | ";
     if(p.second.meta_err) std::cout << std::setw(14) << (double)p.second.meta_err/n_frags << " | ";
     else std::cout << std::setw(14) << " " << " | ";
     if(p.second.timestamp_err) std::cout << std::setw(15) << (double)p.second.timestamp_err/n_frags << " | ";
     else std::cout << std::setw(15) << " " << " | ";
     if(p.second.convert_count_err) std::cout << std::setw(19) << (double)p.second.convert_count_err/n_frags << " | ";
     else std::cout << std::setw(19) << " " << " | ";
     if(p.second.error_fields_set) std::cout << std::setw(16) << (double)p.second.error_fields_set/n_frags;
     else std::cout << std::setw(16) << " ";
 
     std::cout << '\n';
   }
 }