OnlineUnpack.cxx

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
/// \file    OnlineUnpack.cxx
/// \brief   Unpack the online data to DDT format
///
/// \author  janzirn@fnal.gov
////////////////////////////////////////////////////////////////////////
#include "DDTCore/OnlineUnpack.h"
#include "DDTCore/WaveformProcessor.h"

#include "DAQDataFormats/RawTrigger.h"
#include "DAQDataFormats/RawTriggerHeader.h"
#include "DAQDataFormats/RawTriggerTime.h"
#include "DAQDataFormats/RawTriggerMask.h"
#include "DAQDataFormats/RawTriggerTimingMarker.h"
#include "DAQDataFormats/RawDataBlock.h"
#include "DAQDataFormats/RawMicroBlock.h"
#include "RawFileParser/RawFileParser.h"
#include "NovaDAQConventions/DAQConventions.h"
#include "DAQChannelMap/DAQChannelMap.h"

#include "canvas/Utilities/Exception.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "messagefacility/MessageLogger/MessageLogger.h"

#include <iostream>
#include <boost/algorithm/string.hpp>

namespace novaddt{

//-----------------------------------------------------------------------------
//Constructor
OnlineUnpack::OnlineUnpack(const std::string* file_name) :
     fFilterCorruptedNanoslices  (false)
    ,fDetId                      (novadaq::cnv::kNEARDET)
    ,fNumberOfNonemptyMicroblocks(0)
    ,fHitNumber                  (0)
    ,fCurrentFileName            (file_name)
{
}

//-----------------------------------------------------------------------------
//Destructor
OnlineUnpack::~OnlineUnpack()
{ 
}

//-----------------------------------------------------------------------------
bool OnlineUnpack::ProcessRawEvent (void*                           buffer,
                                    std::vector<novaddt::DAQHit>*   hits,
                                    novaddt::EventHeader*            evt_header){

    // First set the pointer to the raw Buffer.
    fRawEvent.setBufferSource(buffer);

    return ProcessRawEvent_(hits, evt_header);
}

//-----------------------------------------------------------------------------
bool OnlineUnpack::ProcessRawEvent(rawfileparser::RawFileParser&   parser,
                                   std::vector<novaddt::DAQHit>*   hits,
                                   novaddt::EventHeader*            evt_header){
    errno = 0; // Currently our only way of distinguishing EOF from read failure.
    const bool result = parser.getEvent(fRawEvent);
    if (errno) {
      throw art::Exception(art::errors::FileReadError)
        << "Read error attempting to obtain next raw event:"
        << strerror(errno) << ".\n";
    }
    return result?ProcessRawEvent_(hits,evt_header):false;
}

//-----------------------------------------------------------------------------
bool OnlineUnpack::ProcessRawEvent_(std::vector<novaddt::DAQHit>*   hits,
                                    novaddt::EventHeader*            evt_header){

    // This will give us access to accurate TDC and ADC info 
    art::ServiceHandle<novaddt::WaveformProcessor> wpr; 

    /// Variable that is saying whether there was at least one Microblock
    /// We are getting detector ID from microblocks. If there is none, we'll take it from Configuration Block
    fNumberOfNonemptyMicroblocks = 0;

    /// Checking for the markers
    if (   fRawEvent.getHeaderMarkerLeft()  != daqdataformats::raweventhdr::Marker_value[0]
        || fRawEvent.getHeaderMarkerRight() != daqdataformats::raweventhdr::Marker_value[1]){
        std::cout<<"Event Header markers are wrong\n";

        return false;
    }

    /// Trigger pointer
    daqdataformats::RawTrigger* trigger = fRawEvent.getTrigger();


    /// Checking Trigger markers
#ifdef DAQDATAFORMATS_VERSIONING_IS_IMPLEMENTED
    if ( trigger->getTriggerHeader()->getDelimiter() != daqdataformats::triggerheader::TriggerHeaderDelimiter  ){
#else
    if ( trigger->getTriggerHeader()->getDelimiter() != daqdataformats::TriggerHeaderDelimiter  ){
#endif

        std::cout<<"Trigger Header markers are wrong\n";
        return false;
    }
    // Now the unpacking...

    /// Filling Trigger stuff
    fUnpackedEventParameters.fTriggerHeader_Source                = trigger->getTriggerHeader()->getSource();
    fUnpackedEventParameters.fTriggerHeader_SourceID              = trigger->getTriggerHeader()->getSourceID();
    fUnpackedEventParameters.fTriggerHeader_SourceSubID           = trigger->getTriggerHeader()->getSourceSubID();
    fUnpackedEventParameters.fTriggerHeader_TriggerNumber         = trigger->getTriggerHeader()->getTriggerNumber();
    fUnpackedEventParameters.fTriggerHeader_MasterTriggerNumber   = trigger->getTriggerHeader()->getMasterTriggerNumber();
    fUnpackedEventParameters.fTriggerTime_GenTime                 = trigger->getTriggerTime()->getTriggerTimeStamp();
    fUnpackedEventParameters.fTriggerTime_ClockSource             = trigger->getTriggerTime()->getClockSource();
    fUnpackedEventParameters.fTriggerTimingMarker_TimeStart       = trigger->getTriggerTimingMarker()->getTriggerStart_baseClock();
    fUnpackedEventParameters.fTriggerTimingMarker_ExtractionStart = trigger->getTriggerTimingMarker()->getTriggerStart_833kHz();
    fUnpackedEventParameters.fTriggerRange_TriggerLength          = trigger->getTriggerRange()->getTriggerLength();
    fUnpackedEventParameters.fTriggerMask_MCBit                   = trigger->getTriggerMask()->getMonteCarloFlag();
    fUnpackedEventParameters.fTriggerMask_TMod                    = trigger->getTriggerMask()->getTrigMod();
    fUnpackedEventParameters.fTriggerMask_TriggerTypesLow         = trigger->getTriggerMask()->getTrigMask_Low();
    fUnpackedEventParameters.fTriggerMask_TriggerTypesHigh        = trigger->getTriggerMask()->getTrigMask_High();
    fUnpackedEventParameters.fTriggerMask_TriggerTypesHigh2       = trigger->getTriggerMask()->getTrigMask_High2();
    fUnpackedEventParameters.fTriggerMask_Prescale                = trigger->getTriggerMask()->getPrescale();
    
    fUnpackedEventParameters.fNumberOfHits = 0;

    /// Loop over DataBlocks
    const uint32_t n_datablocks = fRawEvent.getDataBlockNumber();

    /// Counter for total number of microslices in the event
    uint32_t total_microslices=0;

    uint64_t eventStart = UINT64_MAX;

    for(uint32_t idatablock = 0; idatablock < n_datablocks; ++idatablock){

      // Set the datablock
      fRawEvent.setFloatingDataBlock(idatablock);
      daqdataformats::RawDataBlock* datablock = fRawEvent.getFloatingDataBlock();

      /// Checking DataBlock markers
#ifdef DAQDATAFORMATS_VERSIONING_IS_IMPLEMENTED
      if ( datablock->getHeader()->getMarker() != daqdataformats::datablockheader::DataBlock_Marker ){
#else
      if ( datablock->getHeader()->getMarker() != daqdataformats::datablock::DataBlock_Marker ){
#endif
        std::cout<<"DataBlock Header markers are wrong\n";
        return false;
      }// end of checking DataBlock markers

      /// Loop over the MicroBlocks
      const uint32_t n_microblocks = datablock->getNumMicroBlocks();

      for(uint32_t imicro = 0; imicro < n_microblocks; ++imicro){

        /// Set the microblock
        datablock->setFloatingMicroBlock(imicro);
        
        daqdataformats::RawMicroBlock* microblock = (daqdataformats::RawMicroBlock*)datablock->getFloatingMicroBlock();
        daqdataformats::RawMicroSlice* microslice = (daqdataformats::RawMicroSlice*)microblock->getMicroSlice();

        /// Doing various checks
        /// 1. Cannot be less than 8
        if(microslice->getHeader()->getByteCount() < 8) return false;

#ifndef DAQDATAFORMATS_VERSIONING_IS_IMPLEMENTED
        /// 2. Has to be dividable by 4 if nanoslice is version 0
        if(microslice->getHeader()->getByteCount() % 4) return false;
#endif
        /// 3. Cannot be empty
        if(!microslice->getHeader()->getDataPresent() && microslice->getHeader()->getByteCount()!= 8) return false;

        /// Increment the total number of valid microslices in the event
        total_microslices++;    

        /// Get the Detector and a DAQChannelMap
        fDetId = (int)microblock->getHeader()->getDetId();
        //daqchannelmap::DAQChannelMap* dMap = daqchannelmap::DAQChannelMap::getInstance(fDetId);
        auto dMap = daqchannelmap::DAQChannelMap::getInstance(fDetId);

        /// Increment fNumberOfNonemptyMicroblocks
        ++fNumberOfNonemptyMicroblocks;

        /// Diblock number
        const uint32_t diblock = microblock->getHeader()->getDiblockId();
        /// DCM number in the diblock
        const uint32_t dcmid   = microblock->getHeader()->getDCMId();

        /// Get the time and compare to event start time
        uint64_t tmpTime = microslice->getTime();
        if(tmpTime < eventStart){
          eventStart = tmpTime;
        }

        fUnpackedEventParameters.fNumberOfHits += microslice->getNumNanoSlices();

        
        /// Loop over NanoSlices
        const uint32_t n_nanoslices = microslice->getNumNanoSlices();
        for(uint32_t inano = 0; inano < n_nanoslices; ++inano){
          
          /// Set the nanoslice
          microslice->setFloatingNanoSlice(inano);
          
          daqdataformats::RawNanoSlice*             nanoslice        = (daqdataformats::RawNanoSlice*)microslice->getFloatingNanoSlice();
          const daqdataformats::RawNanoSliceHeader* nanoslice_header = (daqdataformats::RawNanoSliceHeader*)nanoslice->getHeader();


          /// See if we need to filter the nanoslice
          if(fFilterCorruptedNanoslices){
              /// NanoSlice has to have DataPresent Flag
              if(!nanoslice_header->getDataPresent()) continue;
          }// end of filtering


          /// DCM link number for the FEB
          const uint32_t             dcm_link    = nanoslice_header->getFEBId();
          /// Pixel number
          const uint32_t             pixel       = nanoslice_header->getPixelAddr();
          /// Get the daq channel for the hit
          const daqchannelmap::dchan daq_channel = dMap->encodeDChan(fDetId, diblock, dcmid, dcm_link, pixel);

          try{
            // DAQChannelMap is fixed to correctly map DAQ to the Offline, at least
            // for the first 4 blocks of any detector!! A further fix is being done
            // for the AA DiBlock interfaces that are present beyond this.
            dMap->getDetector(daq_channel);
            dMap->getDiBlock(daq_channel);
            dMap->getDCM(daq_channel);
            dMap->getFEB(daq_channel);
            dMap->getPixel(daq_channel);
            dMap->getView(daq_channel);
          }
          catch(...){
            mf::LogError("BadDAQChannel") << "we have a bad DAQChannel " << daq_channel
                                          << " don't make a digit from it";
            continue;
          }

          /// Hit time and charge
          wpr->setup(microslice, nanoslice);
          novaddt::ADC ADC = wpr->getADC();
          novaddt::TDC TDC = wpr->getTDC();

          /// Push DAQHits
          fHit = novaddt::DAQHit(fDetId, daq_channel, ADC, TDC);
          hits->push_back(fHit);

          /// Advance the hit number
          ++fHitNumber;
        }// end of loop over nanoslices

        //std::cout<<"end micro "<<imicro<<"\n";
      }// end of loop over microblocks
    }// end of loop over datablocks
      
      /// Bug in Datalogger that has detector ID in Configuration block different than in Microblocks
      /// Try to figure out the detector from the file name
      if(fNumberOfNonemptyMicroblocks == 0){
          if(!getDetIDFromFileName(fCurrentFileName)){
              std::cout<<"From "<<__PRETTY_FUNCTION__<<":"<<__LINE__;
              std::cout<<" Warning!!! Could not get the detector ID.";
              std::cout<<" The empty event "<<fRawEvent.getEventNumber();
              std::cout<<" will be marked to have DetectorID="<<fDetId;
              std::cout<<"("<<novadaq::cnv::DetInfo::GetName(fDetId)<<")\n";
          }
      }// end of trying to figure out the detector

      /// Now filling novaddt::EventHeader (maybe...)
      
      evt_header->totalBytes =     fRawEvent.getEventSize();
      evt_header->eventNumber =    fRawEvent.getEventNumber();
      evt_header->datablockCount = fRawEvent.getDataBlockNumber();
      evt_header->missingData =    fRawEvent.isEventIncomplete();
      evt_header->timeStart =      eventStart;      

      return true;
}// end of ProcessRawEvent_


//------------------------------------------------------------------------------
// Try to get Detector ID from the file name
bool OnlineUnpack::getDetIDFromFileName(const std::string* file_name) {

    if(!file_name) return false;

    if     (boost::find_first(*file_name, "ndos") || boost::find_first(*file_name, "NDOS")){
        fDetId = novadaq::cnv::kNDOS;
    }
    else if(boost::find_first(*file_name, "fardet") || boost::find_first(*file_name, "FarDet")){
        fDetId = novadaq::cnv::kFARDET;
    }
    else if(boost::find_first(*file_name, "neardet") || boost::find_first(*file_name, "NearDet")){
        fDetId = novadaq::cnv::kNEARDET;
    }

    return true;
}


}//end namespace