RawEventUnpacker.cxx

Go to the documentation of this file.

#include <iostream>
#include "DAQDataFormats/RawEvent.h"
#include "DAQDataFormats/RawTrigger.h"
#include "DAQDataFormats/RawTriggerMask.h"
#include "DAQDataFormats/RawTriggerHeader.h"
#include "DAQDataFormats/RawDataBlock.h"
#include "DAQDataFormats/RawMicroBlock.h"
#include "DAQDataFormats/RawMicroSlice.h"
#include "DAQDataFormats/RawNanoSlice.h"
#include "DAQChannelMap/DAQChannelMap.h"
#include "DAQChannelMap/HardwareDisplay.h"
#include "NovaTimingUtilities/TimingUtilities.h"
#include "OnlineMonitoring/util/Settings.h"
#include "OnlineMonitoring/producer/RawEventUnpacker.h"
#include "OnlineMonitoring/producer/RawEventSummary.h"
#include "OnlineMonitoring/producer/DataBlockSummary.h"
#include "OnlineMonitoring/producer/MicroSliceSummary.h"
#include "OnlineMonitoring/producer/NanoSliceSummary.h"
#include "OnlineMonitoring/producer/SummarySubscriber.h"

using namespace om;

static const double kUSEC_PER_TDC = (1.0E6/64.0E6);
static const unsigned int kADC_ERROR = 0xFFFFFFFF;

RawEventUnpacker& RawEventUnpacker::Instance() 
{
  static RawEventUnpacker tupac;
  return tupac;
}

//......................................................................

RawEventUnpacker::RawEventUnpacker() : 
  fHardwareMapping(new daqchannelmap::HardwareDisplay)
{
  fHardwareMapping->SetupDet(Settings::Instance().fDet);
}

//......................................................................

RawEventUnpacker::~RawEventUnpacker() {
  if(fHardwareMapping) {delete fHardwareMapping; fHardwareMapping = 0;}
}

//......................................................................

void RawEventUnpacker::SetDebug(bool debug) { fDebug = debug; }

//......................................................................

void RawEventUnpacker::SubscribeToRawEventSummary(SummarySubscriber* s)
{
  fRESSubscriber.push_back(s);
}

//......................................................................

void RawEventUnpacker::SubscribeToDataBlockSummary(SummarySubscriber* s)
{
  fDBSSubscriber.push_back(s);
}

//......................................................................

void RawEventUnpacker::SubscribeToMicroSliceSummary(SummarySubscriber* s)
{
  fMSSSubscriber.push_back(s);
}

//......................................................................

void RawEventUnpacker::SubscribeToNanoSliceSummary(SummarySubscriber* s)
{
  fNSSSubscriber.push_back(s);
}

//......................................................................

void RawEventUnpacker::UnpackRawEvent(daqdataformats::RawEvent& rawevt)
{
  RawEventSummary evtsum;
  
  evtsum.fRun             = rawevt.getRunNumber();
  evtsum.fSubrun          = rawevt.getSubrun();
  evtsum.fEvent           = rawevt.getEventNumber();
  evtsum.fNdatablock      = rawevt.getDataBlockNumber();
  evtsum.fEventIncomplete = rawevt.getHeader()->isEventIncomplete();
  evtsum.fTrigger         = rawevt.getTrigger()->getTriggerMask()->getTriggerMask();
  evtsum.fMasterTrigger   = rawevt.getTrigger()->getTriggerHeader()->getMasterTriggerNumber();
  evtsum.fT0              = rawevt.getTrigger()->getTriggerStart();
  evtsum.fRange           = rawevt.getTrigger()->getTriggerRange()->getTriggerLength();

  // The upper 32 bits of T0 comes from the DCM time.  To be able to compare T0
  // to the TDC time from the nanoslices, we only want the lower 32 bits of T0.
  const unsigned long int mask32 = 0xFFFFFFFFUL;
  unsigned long int T0lo         = evtsum.fT0 & mask32;
  evtsum.fT0lo32Usec             = T0lo*kUSEC_PER_TDC;
  
  uint16_t sec, min, hour, mday, mon;
  uint32_t year;
  novadaq::timeutils::convertNovaTimeToUnixTime(evtsum.fT0,
                                                sec,
                                                min,
                                                hour,
                                                mday,
                                                mon,
                                                year);
  evtsum.fHour = hour + (float)min/60.0 + (float)sec/60.0/60.0;

  if(fDebug) {
    std::cout << "\n(r/sr/evt): "
              << evtsum.fRun    << " / "
              << evtsum.fSubrun << " / "
              << evtsum.fEvent  << "\t"
              << "number of datablocks: "
              << evtsum.fNdatablock << "\n";
    std::cout << "\tDatablocks: (N ublocks, isMissingData)\n";
  }

  unsigned int idata;
  for (idata=0; idata<evtsum.fNdatablock; ++idata) {

    this->UnpackDataBlock(rawevt, idata, evtsum);
  }
  this->PublishRawEventSummary(evtsum);
}

//......................................................................

void RawEventUnpacker::UnpackDataBlock(daqdataformats::RawEvent& rawevt,
                                       unsigned int               idata,
                                       RawEventSummary&           evtsum)
{
  rawevt.setFloatingDataBlock(idata);
  daqdataformats::RawDataBlock& datablock = (*rawevt.getFloatingDataBlock());
  
  DataBlockSummary dbsum;
  dbsum.fNmicroblock = datablock.getNumMicroBlocks();
  dbsum.fMissingData = datablock.getHeader()->isMissingData();

  if(fDebug) {
    std::cout << "\t("
              << dbsum.fNmicroblock << ", "
              << dbsum.fMissingData << ")\n";
  }

  if (datablock.getHeader()->getMarker() == daqdataformats::datablockheader::SummaryBlock_Marker ){
    if(datablock.getHeader()->checkMarker()) {
      return;
    }
  }


  unsigned int imicro;
  for (imicro=0; imicro<dbsum.fNmicroblock; ++imicro) {
    this->UnpackMicroSlice(datablock, imicro, evtsum, dbsum);
  }
  this->PublishDataBlockSummary(evtsum,dbsum);
}

//......................................................................

void RawEventUnpacker::UnpackMicroSlice(daqdataformats::RawDataBlock& datablock,
                                        unsigned int                  imicro, 
                                        RawEventSummary&              evtsum,
                                        DataBlockSummary&             dbsum) 
{
  datablock.setFloatingMicroBlock(imicro);

  daqdataformats::RawMicroBlock& 
    microblock = (*datablock.getFloatingMicroBlock());
  
  daqdataformats::RawMicroSlice&
    microslice = (*microblock.getMicroSlice());

  MicroSliceSummary microsum;
  microsum.fNnanoslice = microslice.getNumNanoSlices();

  microsum.fDet         = microblock.getHeader()->getDetId();
  microsum.fDiblock     = microblock.getHeader()->getDiblockId();
  microsum.fDCM         = microblock.getHeader()->getDCMId();
  microsum.fDataPresent = microslice.getHeader()->getDataPresent();
  microsum.fMCflag      = microslice.getHeader()->getMonteCarloFlag();
  microsum.fByteCount   = microslice.getHeader()->getByteCount();

  evtsum.fDiblocks.insert(    microsum.fDiblock);
  evtsum.fDCMs.    insert(100*microsum.fDiblock+microsum.fDCM);

  unsigned int inano;
  for (inano=0; inano<microsum.fNnanoslice; ++inano) {
    this->UnpackNanoSlice(microslice, inano, evtsum, dbsum, microsum);
  }

  ++evtsum.fNmicroSl;

  this->PublishMicroSliceSummary(evtsum,dbsum,microsum);
}

//......................................................................

void RawEventUnpacker::UnpackNanoSlice(daqdataformats::RawMicroSlice& microslice,
                                       unsigned int                   inano, 
                                       RawEventSummary&               evtsum,
                                       DataBlockSummary&              dbsum,
                                       MicroSliceSummary&             microsum) 
{
  microslice.setFloatingNanoSlice(inano);
  
  daqdataformats::RawNanoSlice&       nanoslice    = (*microslice.getFloatingNanoSlice());
  daqdataformats::RawNanoSliceHeader& nanoslicehdr = (*nanoslice.getHeader());

  NanoSliceSummary nanosum;
  
  nanosum.fFEB  = nanoslicehdr.getFEBId();
  nanosum.fPix  = nanoslicehdr.getPixelAddr();
  nanosum.fTDC  = nanoslice.   getTimeStamp();


  if(fDebug) {
    std::cout << "\n(DB/DCM/FEB/Pix): "
              << "\t" << microsum.fDiblock
              << "\t" << microsum.fDCM
              << "\t" << nanosum.fFEB
              << "\t" << nanosum.fPix;
  }



  unsigned int version = nanoslicehdr.getVersion();
  if(version == 0) {
    nanosum.fADC = nanoslice.getPulseHeight();

    if(fDebug) {
      std::cout << "\nversion: " << version
                << "\tADC: " << nanosum.fADC;
    }
  }
  if(version > 0) {
    // This section is basically copied and pasted from DAQ2RawDigit/RawDigit.cxx
    const unsigned int nSamples     = nanoslice.getNSamples();
    const unsigned int nPretrig     = nanoslice.getNPretriggeredSamples();
    const unsigned int kDCSDistance = 3;   // Look back 3 samples (1.5us in the FD)

    // Check that everything makes sense, otherwise flag the ADC as bad.
    if((nSamples <= nPretrig) || (nPretrig < kDCSDistance))
      nanosum.fADC = kADC_ERROR;
    else
      nanosum.fADC = nanoslice.getValue(nPretrig) - nanoslice.getValue(nPretrig - kDCSDistance);
    
    if(fDebug) {
      std::cout << "\nversion: " << version
                << "\t(nSamples/nPretrig):"
                << " " << nSamples
                << " " << nPretrig
                << "\nADC:";
      for(unsigned int p = 0; p < nSamples; ++p)
        std::cout << " " << nanoslice.getValue(p);
      std::cout << "\tcomputed ADC: " << nanosum.fADC << "\n";

    }
  }


  nanosum.fUsec = nanosum.fTDC*kUSEC_PER_TDC;
  
  nanosum.fDataPresent = nanoslicehdr.getDataPresent();
  nanosum.fLinkStatus  = nanoslicehdr.getLinkStatus();
  nanosum.fDebugMode   = nanoslicehdr.getDebugMode();
  nanosum.fFEBStatus   = nanoslicehdr.getFEBStatus();

  // (1<<4) cooresponds to "Enable DAQ" which you want to be set to 1.
  if (nanosum.fDataPresent == false || nanosum.fLinkStatus == false ||
      nanosum.fDebugMode   == true  || nanosum.fFEBStatus  != (1<<4)) {
    ++evtsum.fNfeberr;
  }

  daqchannelmap::DAQChannelMap*
    cmap = daqchannelmap::DAQChannelMap::getInstance((novadaq::cnv::DetId)microsum.fDet);
  nanosum.fDChan = cmap->encodeDChan((novadaq::cnv::DetId)microsum.fDet,
                                     microsum.fDiblock,
                                     microsum.fDCM,
                                     nanosum.fFEB,
                                     nanosum.fPix);
  nanosum.fLChan = cmap->encodeLChan(nanosum.fDChan);
  nanosum.fPlane = cmap->getPlane(nanosum.fLChan);
  nanosum.fCell  = cmap->getCell(nanosum.fLChan);;

  nanosum.fView = cmap->getView(nanosum.fDChan);

  fHardwareMapping->DAQToXY(microsum.fDiblock,
                            microsum.fDCM,
                            nanosum. fFEB,
                            nanosum. fPix,
                            &nanosum.fHdwX,
                            &nanosum.fHdwY);
  evtsum.fFEBs.insert(10000*microsum.fDiblock+100*microsum.fDCM+nanosum.fFEB);
  ++evtsum.fNhit;

  this->PublishNanoSliceSummary(evtsum,dbsum,microsum,nanosum);
}

//......................................................................

void RawEventUnpacker::PublishRawEventSummary(const RawEventSummary& r)
{
  std::list<SummarySubscriber*>::iterator i(fRESSubscriber.begin());
  std::list<SummarySubscriber*>::iterator e(fRESSubscriber.end());
  for (;i!=e; ++i) (*i)->GetRawEventSummary(r);
}

//......................................................................

void RawEventUnpacker::PublishDataBlockSummary(const RawEventSummary&  r,
                                               const DataBlockSummary& d)
{
  std::list<SummarySubscriber*>::iterator i(fDBSSubscriber.begin());
  std::list<SummarySubscriber*>::iterator e(fDBSSubscriber.end());
  for (;i!=e; ++i) (*i)->GetDataBlockSummary(r,d);
}

//......................................................................

void RawEventUnpacker::PublishMicroSliceSummary(const RawEventSummary&   r,
                                                const DataBlockSummary&  d,
                                                const MicroSliceSummary& m)
{
  std::list<SummarySubscriber*>::iterator i(fMSSSubscriber.begin());
  std::list<SummarySubscriber*>::iterator e(fMSSSubscriber.end());
  for (;i!=e; ++i) (*i)->GetMicroSliceSummary(r,d,m);
}

//......................................................................

void RawEventUnpacker::PublishNanoSliceSummary(const RawEventSummary&   r,
                                               const DataBlockSummary&  d,
                                               const MicroSliceSummary& m,
                                               const NanoSliceSummary&  n)
{
  std::list<SummarySubscriber*>::iterator i(fNSSSubscriber.begin());
  std::list<SummarySubscriber*>::iterator e(fNSSSubscriber.end());
  for (;i!=e; ++i) (*i)->GetNanoSliceSummary(r,d,m,n);
}

////////////////////////////////////////////////////////////////////////