Line data    Source code

       1              : /**
       2              :  * @file DAPHNEStreamFrameProcessor.hpp DAPHNE specific Task based raw processor
       3              :  * implementation for streaming mode
       4              :  *
       5              :  * This is part of the DUNE DAQ , copyright 2020.
       6              :  * Licensing/copyright details are in the COPYING file that you should have
       7              :  * received with this code.
       8              :  */
       9              : #include "fdreadoutlibs/daphne/DAPHNEStreamFrameProcessor.hpp"
      10              : #include "fddetdataformats/DAPHNEStreamFrame.hpp"
      11              : 
      12              : #include <atomic>
      13              : #include <functional>
      14              : #include <memory>
      15              : #include <string>
      16              : 
      17              : using dunedaq::datahandlinglibs::logging::TLVL_BOOKKEEPING;
      18              : using dunedaq::datahandlinglibs::logging::TLVL_FRAME_RECEIVED;
      19              : 
      20              : namespace dunedaq {
      21              : namespace fdreadoutlibs {
      22              : 
      23              : void
      24            0 : DAPHNEStreamFrameProcessor::conf(const appmodel::DataHandlerModule* conf)
      25              : {
      26            0 :   datahandlinglibs::TaskRawDataProcessorModel<types::DAPHNEStreamSuperChunkTypeAdapter>::add_preprocess_task(
      27            0 :     std::bind(&DAPHNEStreamFrameProcessor::timestamp_check, this, std::placeholders::_1));
      28              :   // m_tasklist.push_back( std::bind(&DAPHNEStreamFrameProcessor::frame_error_check, this, std::placeholders::_1) );
      29            0 :   TaskRawDataProcessorModel<types::DAPHNEStreamSuperChunkTypeAdapter>::conf(conf);
      30            0 : }
      31              : 
      32              : /**
      33              :  * Pipeline Stage 1.: Check proper timestamp increments in DAPHNE frame
      34              :  * */
      35              : void
      36            0 : DAPHNEStreamFrameProcessor::timestamp_check(frameptr fp)
      37              : {
      38              :   /* Let Source Emulator deal with this
      39              :     // If EMU data, emulate perfectly incrementing timestamp
      40              :     if (inherited::m_emulator_mode) { // emulate perfectly incrementing timestamp
      41              :       uint64_t ts_next = m_previous_ts + 64; // NOLINT(build/unsigned)
      42              :       auto df = reinterpret_cast<daphneframeptr>(((uint8_t*)fp));  // NOLINT
      43              :       for (unsigned int i = 0; i < fp->get_num_frames(); ++i) { // NOLINT(build/unsigned)
      44              :         //auto wfh = const_cast<dunedaq::fddetdataformats::WIB2Header*>(wf->get_wib_header());
      45              :         df->set_timestamp(ts_next);
      46              :         ts_next += 64;
      47              :         df++;
      48              :       }
      49              :     }
      50              :   */
      51              :   // Acquire timestamp
      52            0 :   m_current_ts = fp->get_timestamp();
      53            0 :   uint64_t k_clock_frequency = 62500000; // NOLINT(build/unsigned)
      54            0 :   TLOG_DEBUG(TLVL_FRAME_RECEIVED) << "Received DAPHNEStream frame timestamp value of " << m_current_ts << " ticks (..."
      55            0 :                                   << std::fixed << std::setprecision(8)
      56            0 :                                   << (static_cast<double>(m_current_ts % (k_clock_frequency * 1000)) /
      57            0 :                                       static_cast<double>(k_clock_frequency))
      58            0 :                                   << " sec)"; // NOLINT
      59              : 
      60              :   // Check timestamp
      61              :   // RS warning : not fixed rate!
      62              :   // if (m_current_ts - m_previous_ts != ???) {
      63              :   //  ++m_ts_error_ctr;
      64              :   //}
      65              : 
      66            0 :   if (m_ts_error_ctr > 1000) {
      67            0 :     if (!m_problem_reported) {
      68            0 :       TLOG() << "*** Data Integrity ERROR *** Timestamp continuity is completely broken! "
      69            0 :              << "Something is wrong with the FE source or with the configuration!";
      70            0 :       m_problem_reported = true;
      71              :     }
      72              :   }
      73              : 
      74            0 :   m_previous_ts = m_current_ts;
      75            0 :   m_last_processed_daq_ts = m_current_ts;
      76            0 : }
      77              : 
      78              : /**
      79              :  * Pipeline Stage 2.: Check DAPHNE headers for error flags
      80              :  * */
      81              : void
      82            0 : DAPHNEStreamFrameProcessor::frame_error_check(frameptr /*fp*/)
      83              : {
      84              :   // check error fields
      85            0 : }
      86              : 
      87              : } // namespace fdreadoutlibs
      88              : } // namespace dunedaq