OnlineUnpack.cxx

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
/// \file    OnlineUnpack.cxx
/// \brief   Unpack the online data to offline format
///
/// \version $Id: OnlineUnpack.cxx,v 1.26 2012-11-09 17:22:59 jpaley Exp $
/// \author  brebel@fnal.gov
////////////////////////////////////////////////////////////////////////
#include "DAQ2RawDigit/OnlineUnpack.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 "DAQChannelMap/DAQChannelMap.h"
#include "CMap/service/DetectorService.h"
#include "RawData/DAQHeader.h"
#include "RawData/RawTrigger.h"
#include "RawData/FlatDAQData.h"
#include "RawData/RawSumDropMB.h"
#include "RawData/RawSumDCM.h"
#include "NovaDAQConventions/DAQConventions.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>

#include "TH1F.h"


namespace daq2raw{

//-----------------------------------------------------------------------------
//Constructor
OnlineUnpack::OnlineUnpack(TH1F *pulseHeightVals, TH1F *timeStampVals, TH1F *triggerVals, const std::string* file_name) :
     fFilterCorruptedNanoslices  (false)
    ,fDetId                      (novadaq::cnv::kUNKNOWN_DET)
    ,fNumberOfNonemptyMicroblocks(0)
    ,fPulseHeight_values         (pulseHeightVals)
    ,fTimeStamp_values           (timeStampVals)
    ,fTrigger_values             (triggerVals)
    ,fTDC_values                 (nullptr)
    ,fHitNumber                  (0)
    ,fCurrentFileName            (file_name)
{
}

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

//-----------------------------------------------------------------------------
bool OnlineUnpack::ProcessRawEvent (void*                           buffer,
                                    std::vector<rawdata::RawDigit>* digits,
                                    rawdata::RawTrigger*            raw_trigger,
                                    rawdata::RawSumDropMB*            raw_sumDropMB,
                                    rawdata::RawSumDCM*            raw_sumDCM,
                                    rawdata::FlatDAQData*           flat_daq_data,
                                    rawdata::DAQHeader*             daq_header){

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

    return ProcessRawEvent_(digits, raw_trigger, raw_sumDropMB, raw_sumDCM, flat_daq_data, daq_header);
}

//-----------------------------------------------------------------------------
bool OnlineUnpack::ProcessRawEvent(rawfileparser::RawFileParser&   parser,
                                   std::vector<rawdata::RawDigit>* digits,
                                   rawdata::RawTrigger*            raw_trigger,
                                   rawdata::RawSumDropMB*            raw_sumDropMB,
                                   rawdata::RawSumDCM*            raw_sumDCM,
                                   rawdata::FlatDAQData*           flat_daq_data,
                                   rawdata::DAQHeader*             daq_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_(digits, raw_trigger, raw_sumDropMB, raw_sumDCM, flat_daq_data, daq_header):false;
}

//-----------------------------------------------------------------------------
bool OnlineUnpack::ProcessRawEvent_(std::vector<rawdata::RawDigit>* digits,
                                    rawdata::RawTrigger*            raw_trigger,
                                    rawdata::RawSumDropMB*            raw_sumDropMB,
                                    rawdata::RawSumDCM*            raw_sumDCM,
                                    rawdata::FlatDAQData*           flat_daq_data,
                                    rawdata::DAQHeader*             daq_header){


    /// 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;
    /// Resizing the size of the FlatDAQData buffer to the size of the event
    /// fRawEvent.sizeofdata() returns the size in words, so we need to multiply by 4
    flat_daq_data->fRawBuffer.resize(fRawEvent.sizeofdata() * 4);

    /// Now, fill FlatDAQData object with the event
    fRawEvent.writeData(flat_daq_data->getRawBufferPointer());

#ifdef RUNCHECKS
      std::cout << "Checks = " <<
      qc.checkEvent(fRawEvent) << std::endl;
#endif

    /// 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();
    
    raw_trigger->fTriggerHeader_Source                 = fUnpackedEventParameters.fTriggerHeader_Source;
    raw_trigger->fTriggerHeader_SourceID               = fUnpackedEventParameters.fTriggerHeader_SourceID;
    raw_trigger->fTriggerHeader_SourceSubID            = fUnpackedEventParameters.fTriggerHeader_SourceSubID;
    raw_trigger->fTriggerHeader_TriggerNumber          = fUnpackedEventParameters.fTriggerHeader_TriggerNumber;
    raw_trigger->fTriggerHeader_MasterTriggerNumber    = fUnpackedEventParameters.fTriggerHeader_MasterTriggerNumber;
    raw_trigger->fTriggerTime_GenTime                  = fUnpackedEventParameters.fTriggerTime_GenTime;
    raw_trigger->fTriggerTime_ClockSource              = fUnpackedEventParameters.fTriggerTime_ClockSource;
    raw_trigger->fTriggerTimingMarker_TimeStart        = fUnpackedEventParameters.fTriggerTimingMarker_TimeStart;
    raw_trigger->fTriggerTimingMarker_ExtractionStart  = fUnpackedEventParameters.fTriggerTimingMarker_ExtractionStart;
    raw_trigger->fTriggerRange_TriggerLength           = fUnpackedEventParameters.fTriggerRange_TriggerLength;
    raw_trigger->fTriggerMask_TMod                     = fUnpackedEventParameters.fTriggerMask_TMod;
    raw_trigger->fTriggerMask_TriggerType              = trigger->getTriggerMask()->getTriggerMask();
    raw_trigger->fTriggerMask_Prescale                 = fUnpackedEventParameters.fTriggerMask_Prescale;
    if(fUnpackedEventParameters.fTriggerMask_MCBit)raw_trigger->fTriggerMask_MCBit = true;
    else                                           raw_trigger->fTriggerMask_MCBit = false;

    if(fTrigger_values)  fTrigger_values->Fill(fUnpackedEventParameters.fTriggerTimingMarker_TimeStart);
    
    fUnpackedEventParameters.fNumberOfDigits = 0;

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

    bool isSummaryEvent = false;

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

    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::SummaryBlock_Marker ){

        if(datablock->getHeader()->checkMarker()) {
          isSummaryEvent = true;
        }
      }
      else 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

        if(isSummaryEvent) {
          daqdataformats::RawSummaryDroppedMicroblock* rsdm = (daqdataformats::RawSummaryDroppedMicroblock*)datablock->getDroppedMicroblock();
          
          raw_sumDropMB->fSumTrig_NumDroppedMicroblocks =
            rsdm->getNumDroppedMicroblocks();
          raw_sumDropMB->fSumTrig_TimeStamp = rsdm->getTimeStamp();
          raw_sumDropMB->fSumTrig_TimeStampLow = rsdm->getTimeStampLow();
          raw_sumDropMB->fSumTrig_TimeStampHigh = rsdm->getTimeStampHigh();
          raw_sumDropMB->fSumTrig_BuffId = datablock->getBuffId();

          daqdataformats::RawSummaryDCMData* summaryDCMData = (daqdataformats::RawSummaryDCMData*)datablock->getDCMData();
          daqdataformats::RawSummaryDCMDataPoint* thePoint = (daqdataformats::RawSummaryDCMDataPoint*)datablock->getDCMData();
          
          for(uint32_t ient = 0; ient < summaryDCMData->getHeader()->getNumEntries(); ++ient) {
            thePoint = summaryDCMData->getDataPoint(ient);
            if(!thePoint) continue;
            
            uint8_t dib = thePoint->getDCMID();
            uint8_t dcm = (thePoint->getDCMID() >> 8) & 0x1F;
            uint8_t det = (thePoint->getDCMID() >> 13);

            rawdata::RawSumDCMPoint aPoint;
            aPoint.fSumTrig_DCM_dib = dib;
            aPoint.fSumTrig_DCM_dcm = dcm;
            aPoint.fSumTrig_DCM_det = det;
            aPoint.fSumTrig_DCM_Type = (rawdata::RawSumDCMType)thePoint->getDataType();
            aPoint.fSumTrig_DCM_TimeStampLow = thePoint->getTimeStampLow();
            aPoint.fSumTrig_DCM_TimeStampHigh = thePoint->getTimeStampHigh();

            raw_sumDCM->_points.push_back(aPoint);
          }
          continue;
        }

      /// 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++;    

        /// Inform everyone of the detector ID.
        fDetId = (int)microblock->getHeader()->getDetId();
        art::ServiceHandle<ds::DetectorService> ds;
        ds->SetDetector(novadaq::cnv::DetId(fDetId));

        const daqchannelmap::DAQChannelMap* cmap = 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();

        fUnpackedEventParameters.fNumberOfDigits += 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();

#ifdef DAQDATAFORMATS_VERSIONING_IS_IMPLEMENTED
          const uint32_t nanoslice_version = nanoslice_header->getVersion();
#else
          const uint32_t nanoslice_version = 0;
#endif

          /// See if we need to filter the nanoslice
          if(fFilterCorruptedNanoslices){
              /// NanoSlice has to have DataPresent Flag
              if(!nanoslice_header->getDataPresent()) continue;
              /// NanoSlice version 0 has to have Reserved field set to 0xCAFE
              if(nanoslice_version == 0 && !nanoslice->checkReservedForCafe()) 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 = cmap->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.
            cmap->getDetector(daq_channel);
            cmap->getDiBlock(daq_channel);
            cmap->getDCM(daq_channel);
            cmap->getFEB(daq_channel);
            cmap->getPixel(daq_channel);
            cmap->getView(daq_channel);
          }
          catch(...){
            mf::LogError("BadDAQChannel") << "we have a bad DAQChannel " << daq_channel
                                          << " don't make a digit from it";
            continue;
          }

          /// get local channel from the DAQ channel
          const uint32_t local_channel = cmap->encodeLChan(daq_channel);

          /// Event time
#ifdef SUBTRACT_EVENT_TIME_FROM_HIT
          const Long64_t nanoslice_time  = nanoslice->getTimeStamp();
          const Long64_t tdc_time        = raw_trigger->TDCT0();
          const Long64_t time_difference = nanoslice_time - tdc_time;
          const int32_t  TDC             = time_difference;
#else
          const uint32_t TDC             = nanoslice->getTimeStamp();
#endif


          if(fTDC_values)      fTDC_values->Fill(TDC);
          if(fTimeStamp_values)fTimeStamp_values->Fill(nanoslice->getTimeStamp());

          fDigit.SetDaqChannel(daq_channel);
          fDigit.SetChannel(local_channel);
          fDigit.SetTDC(TDC);

          fDigit.fFrameSequenceNumber = (uint8_t)nanoslice_header->getSequence();
          fDigit.fFEBStatus           = nanoslice_header->getFEBStatus();
          fDigit.fDebugMode           = nanoslice_header->getDebugMode();
          fDigit.fDataPresent         = nanoslice_header->getDataPresent();
          fDigit.fLinkStatus          = nanoslice_header->getLinkStatus();

          fDigit.fVersion             = (uint8_t)nanoslice_version;

          if     (nanoslice_version == 0){
              const int32_t  ADC = nanoslice->getPulseHeight();
              if(fPulseHeight_values) fPulseHeight_values->Fill(ADC);
              fDigit.SetADC(0, ADC);
              fDigit.fReserved = nanoslice->getReserved();
          }
#ifdef DAQDATAFORMATS_VERSIONING_IS_IMPLEMENTED
          else if(nanoslice_version >= 1){

                const int nsamples = nanoslice->getNSamples();

                if(nsamples == 0){
                    mf::LogError("NSamples") << "NSamples cannot be zero\n";
                    assert(false);
                }

                const uint32_t sample0 = nanoslice->getValue(0);
                if(fPulseHeight_values) fPulseHeight_values->Fill(sample0);
                fDigit.SetADC(0, sample0);


                for(int i=1; i<nsamples; ++i){
                    fDigit.SetADC(i, nanoslice->getValue(i));
                   //std::cout<<" ADC"<<i<<":"<<nanoslice->getValue(i);
                }

                //nanoslice->print();


          }// end of cases for nanoslice_version
          else{
              mf::LogError("Version") << "Unknown nanoslice version" << nanoslice_version<<"\n";
              assert(false);
          }
#endif

          /// Push Raw Digit
          digits->push_back(fDigit);

          /// 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 DAQHeader
      daq_header->SetDetId(fDetId);
      daq_header->SetTotalMicroSlices(total_microslices);
      
      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;
    }
    else if(boost::find_first(*file_name, "testbeam") || boost::find_first(*file_name, "TestBeam")){
      fDetId = novadaq::cnv::kTESTBEAM;
    }
    // If file_name exists but no matching detector string found, return false.
    else return false;

    return true;
}


}//end namespace