In This Package:

RawEventHeaderCnv.cc

Go to the documentation of this file.

#include "RawDataIO/IRawDataInputSvc.h"
#include "GaudiKernel/RegistryEntry.h"
#include "RawDataAddress.h"
#include "RawDataEvent.h"
#include "RawEventHeaderCnv.h"

#include "Event/RawEventHeader.h"
#include "Event/RawRom.h"
#include "Event/RawRomFee.h"
#include "Event/RawPmtChannel.h"

using namespace std;
using namespace DayaBay;
using namespace dyb;

extern const CLID CLID_RawEventHeaderCnv;

extern const CLID CLID_DataObject;

RawEventHeaderCnv::RawEventHeaderCnv(unsigned char /*storageType*/, const CLID& /*clid*/, ISvcLocator* svc)
: Converter(RAWDATA_StorageType, classID(), svc)
  , m_log(msgSvc(), "RawEventHeaderCnv")
{
  initialize();
}

RawEventHeaderCnv::RawEventHeaderCnv(ISvcLocator*& svc)
: Converter(RAWDATA_StorageType, classID(), svc)
  , m_log(msgSvc(), "RawEventHeaderCnv")
{
  initialize();
}

StatusCode RawEventHeaderCnv::initialize()
{
  m_log << MSG::DEBUG << "initialize()" << endreq;

  m_log << MSG::DEBUG << "  query the service RawDataInputSvc." << endreq;
  IService* svc = 0;
  StatusCode sc = serviceLocator()->getService("RawDataInputSvc", svc, true);
  if (sc.isFailure()) {
    m_log << MSG::ERROR << "RawDataInputSvc could not be retrieved" << endreq;
    return sc;
  }
  svc->addRef();

  sc = svc->queryInterface(IID_IRawDataInputSvc, (void**) & m_inputSvc);
  if (sc.isFailure()) {
    m_log << MSG::ERROR << "queryInterface(IID_IRawDataInputSvc) failed" << endreq;
    return StatusCode::FAILURE;
  }

  return StatusCode::SUCCESS;
}


StatusCode RawEventHeaderCnv::updateObj(IOpaqueAddress* pAddr, DataObject* pObj)
{
  m_log << MSG::DEBUG << "updateObj()" << endreq;
  return Converter::updateObj(pAddr, pObj);
}

StatusCode RawEventHeaderCnv::createObj(IOpaqueAddress* /*pAddr*/, DataObject*& pObj)
{
  m_log << MSG::DEBUG << "createObj()" << endreq;

  RawEventHeader* rawEventHeader = new RawEventHeader();
  pObj = rawEventHeader;

  if(m_inputSvc->m_inputSvcVersion==2) {
    DayaBay::RawEvent *event = m_inputSvc->currentRawEventClone();
    if (event == NULL) {
      m_log << MSG::INFO << "The RawEvent returned is not valid. Please declare RawEventHeader in RawDataInputSvc as true." << endreq;
      return StatusCode::FAILURE;
    }

    unpackEvent(event, rawEventHeader);
  }

  else {
    RawDataEvent* rawEvt = m_inputSvc->currentEvent();
    if (rawEvt == NULL) {
      m_log << MSG::INFO << "The RawDataEvent returned is not valid." << endreq;
      return StatusCode::FAILURE;
    }

    vector<RawRom*> rawRoms;
    for (unsigned int i = 0; i < rawEvt->m_modules.size(); i++) {
      switch (rawEvt->m_modules[i]->m_type) {
        case kRomLtb:
          {
            RawDataEvent::RomLtb* romLtb = dynamic_cast<RawDataEvent::RomLtb*>(rawEvt->m_modules[i]);
            RawRom *rawRomLtb = convertRomLtb(romLtb);
            rawRomLtb->setHeader(rawEventHeader);
            rawRoms.push_back(rawRomLtb);
          }
          break;
        case kRomFee:
          {
            RawDataEvent::RomFee* romFee = dynamic_cast<RawDataEvent::RomFee*>(rawEvt->m_modules[i]);
            RawRom *rawRomFee = convertRomFee(romFee);
            rawRomFee->setHeader(rawEventHeader);
            rawRoms.push_back(rawRomFee);
          }
          break;
        default:
          break;
      }
    }

    rawEventHeader->setModules(rawRoms);

    rawEventHeader->setDataBlockNum(rawEvt->m_dataBlockNum);
    rawEventHeader->setDataBlockSize(rawEvt->m_dataBlockSize);
    rawEventHeader->setEvtSize(rawEvt->m_evtSize);
    rawEventHeader->setDetId(rawEvt->m_detId);
    rawEventHeader->setSiteId(rawEvt->m_siteId);
    rawEventHeader->setPositionId(rawEvt->m_positionId);
    rawEventHeader->setRunNum(rawEvt->m_runNum);
    rawEventHeader->setEvtNum(rawEvt->m_evtNum);
    rawEventHeader->setDataType(rawEvt->m_dataType);
    rawEventHeader->setDataTypeSpecific(rawEvt->m_dataTypeSpecific);
    rawEventHeader->setDataStatus(rawEvt->m_dataStatus);
  }

  return StatusCode::SUCCESS;
}

StatusCode RawEventHeaderCnv::createRep(DataObject* pObj, IOpaqueAddress*& pAddr)
{
  m_log << MSG::DEBUG << "createRep()" << endreq;

  RawEventHeader* rdth = dynamic_cast<RawEventHeader*>(pObj);
  if (!rdth) {
    m_log << MSG::ERROR << "Could not downcast Event" << endreq;
    return StatusCode::FAILURE;
  }

  string nm = pObj->registry()->name();
  RawDataAddress* addr = new RawDataAddress(classID(), nm, "");
  pAddr = addr;

  return StatusCode::SUCCESS;
}

StatusCode RawEventHeaderCnv::finalize()
{
  m_log << MSG::DEBUG << "finalize()" << endreq;
  return StatusCode::SUCCESS;
}

RawRom* RawEventHeaderCnv::convertRomFee(const RawDataEvent::RomFee* romFee)
{
  RawRom *rawRom = new RawRomFee();

  RawRomFee *rawRomFee = dynamic_cast<RawRomFee*>(rawRom);
  rawRomFee->setSize(romFee->m_size);
  rawRomFee->setSlot(romFee->m_slot);
  rawRomFee->setType(romFee->m_type);
  rawRomFee->setCbltGA(romFee->m_cbltGA);
  rawRomFee->setCbltModuleType(romFee->m_cbltModuleType);
  rawRomFee->setCbltDataLength(romFee->m_cbltDataLength);

  rawRomFee->setTriggerNum(romFee->m_triggerNum);
  rawRomFee->setTriggerType(romFee->m_triggerType);
  rawRomFee->setStatus(romFee->m_status);
  rawRomFee->setDataLength(romFee->m_dataLength);
  rawRomFee->setVersion(romFee->m_version);

  vector<RawPmtChannel*> rawPmtChannels;
  for (unsigned int j = 0; j < romFee->m_channels.size(); j++) {
    const RawDataEvent::PmtChannel &channel = romFee->m_channels[j];
    rawPmtChannels.push_back(convertPmtChannel(channel));
  }
  rawRomFee->setChannels(rawPmtChannels);

  return rawRom;
}

RawPmtChannel* RawEventHeaderCnv::convertPmtChannel(const RawDataEvent::PmtChannel& pmtChannel)
{
  RawPmtChannel *rawPmtChannel = new RawPmtChannel();

  rawPmtChannel->setChannel(pmtChannel.m_channel);
  rawPmtChannel->setAdc(pmtChannel.m_adc);
  rawPmtChannel->setAdcPeakingCycle(pmtChannel.m_adcPeakingCycle);
  rawPmtChannel->setAdcRange(pmtChannel.m_adcRange);
  rawPmtChannel->setTdc(pmtChannel.m_tdc);
  rawPmtChannel->setTdcHitCount(pmtChannel.m_tdcHitCount);
  rawPmtChannel->setPedestal(pmtChannel.m_pedestal);

  return rawPmtChannel;
}

RawRom* RawEventHeaderCnv::convertRomLtb(const RawDataEvent::RomLtb* romLtb)
{
  RawRom *rawRom = new RawRomLtb();

  RawRomLtb *rawRomLtb = dynamic_cast<RawRomLtb*>(rawRom);

  rawRomLtb->setSize(romLtb->m_size);
  rawRomLtb->setSlot(romLtb->m_slot);
  rawRomLtb->setType(romLtb->m_type);
  rawRomLtb->setCbltGA(romLtb->m_cbltGA);
  rawRomLtb->setCbltModuleType(romLtb->m_cbltModuleType);
  rawRomLtb->setCbltDataLength(romLtb->m_cbltDataLength);

  vector<RawLtbFrame*> rawLtbFrames;
  for (unsigned int j = 0; j < romLtb->m_frames.size(); j++) {
    RawDataEvent::LtbFrame *frame = romLtb->m_frames[j];
    if(frame->m_timestampType && frame->m_GPSValid && frame->m_clockSystemValid) {
      RawDataEvent::LtbFrameUTC* ltbFrameUTC = dynamic_cast<RawDataEvent::LtbFrameUTC*>(frame);
      rawLtbFrames.push_back(convertLtbFrameUTC(ltbFrameUTC));
    } else {
      RawDataEvent::LtbFrameUnix* ltbFrameUnix = dynamic_cast<RawDataEvent::LtbFrameUnix*>(frame);
      rawLtbFrames.push_back(convertLtbFrameUnix(ltbFrameUnix));
    }
  }
  rawRomLtb->setFrames(rawLtbFrames);

  return rawRom;
}

RawLtbFrameUTC* RawEventHeaderCnv::convertLtbFrameUTC(const RawDataEvent::LtbFrameUTC *ltbFrame)
{
  RawLtbFrameUTC *rawLtbFrame = new RawLtbFrameUTC();

  rawLtbFrame->setAccStat(ltbFrame->m_accStat);
  rawLtbFrame->setGPSValid(ltbFrame->m_GPSValid);
  rawLtbFrame->setTimestampType(ltbFrame->m_timestampType);
  rawLtbFrame->setClockSystemValid(ltbFrame->m_clockSystemValid);
  rawLtbFrame->setIltSn(ltbFrame->m_iltSn);
  rawLtbFrame->setRot(ltbFrame->m_rot);
  rawLtbFrame->setTriggerSrc(ltbFrame->m_triggerSrc);
  rawLtbFrame->setNanoSecondLow(ltbFrame->m_nanoSecondLow);
  rawLtbFrame->setNanoSecondHigh(ltbFrame->m_nanoSecondHigh);
  rawLtbFrame->setAccumulationLow(ltbFrame->m_accumulationLow);
  rawLtbFrame->setAccumulationHigh(ltbFrame->m_accumulationHigh);
  rawLtbFrame->setHsum(ltbFrame->m_hsum);
  rawLtbFrame->setEsumComp(ltbFrame->m_esumComp);
  rawLtbFrame->setEsumADC(ltbFrame->m_esumADC);
  rawLtbFrame->setCrossTriggerSrc(ltbFrame->m_crossTriggerSrc);
  rawLtbFrame->setFeeBufferStat(ltbFrame->m_feeBufferStat);
  rawLtbFrame->setLtbBufferStat(ltbFrame->m_ltbBufferStat);
  rawLtbFrame->setDay(ltbFrame->m_day);
  rawLtbFrame->setHour(ltbFrame->m_hour);
  rawLtbFrame->setMinute(ltbFrame->m_minute);
  rawLtbFrame->setSecond(ltbFrame->m_second);
  rawLtbFrame->setTimestamp(ltbFrame->timeStamp());

  return rawLtbFrame;
}

RawLtbFrameUnix* RawEventHeaderCnv::convertLtbFrameUnix(const RawDataEvent::LtbFrameUnix *ltbFrame)
{
  RawLtbFrameUnix *rawLtbFrame = new RawLtbFrameUnix();

  rawLtbFrame->setAccStat(ltbFrame->m_accStat);
  rawLtbFrame->setGPSValid(ltbFrame->m_GPSValid);
  rawLtbFrame->setTimestampType(ltbFrame->m_timestampType);
  rawLtbFrame->setClockSystemValid(ltbFrame->m_clockSystemValid);
  rawLtbFrame->setIltSn(ltbFrame->m_iltSn);
  rawLtbFrame->setRot(ltbFrame->m_rot);
  rawLtbFrame->setTriggerSrc(ltbFrame->m_triggerSrc);
  rawLtbFrame->setNanoSecondLow(ltbFrame->m_nanoSecondLow);
  rawLtbFrame->setNanoSecondHigh(ltbFrame->m_nanoSecondHigh);
  rawLtbFrame->setAccumulationLow(ltbFrame->m_accumulationLow);
  rawLtbFrame->setAccumulationHigh(ltbFrame->m_accumulationHigh);
  rawLtbFrame->setHsum(ltbFrame->m_hsum);
  rawLtbFrame->setEsumComp(ltbFrame->m_esumComp);
  rawLtbFrame->setEsumADC(ltbFrame->m_esumADC);
  rawLtbFrame->setCrossTriggerSrc(ltbFrame->m_crossTriggerSrc);
  rawLtbFrame->setFeeBufferStat(ltbFrame->m_feeBufferStat);
  rawLtbFrame->setLtbBufferStat(ltbFrame->m_ltbBufferStat);
  rawLtbFrame->setUnixSecLow(ltbFrame->m_unixSecLow);
  rawLtbFrame->setUnixSecHigh(ltbFrame->m_unixSecHigh);
  rawLtbFrame->setTimestamp(ltbFrame->timeStamp());

  return rawLtbFrame;
}

// Unpack raw data into RawEventHeader
StatusCode RawEventHeaderCnv::unpackEvent(DayaBay::RawEvent* event, 
    DayaBay::RawEventHeader* rawEventHeader)
{
  m_log << MSG::DEBUG << "unpackEvent" << endreq;

  vector<RawRom*> rawRoms;
  // Loop over modules
  while( DayaBay::RawModule* module = event->nextModule() ){
    StatusCode sc;
    if( module->isLocalTriggerModule() ){
      m_log << MSG::DEBUG << "LocalTriggerModule" << endreq;
      RawRom *rawRomLtb = unpackLtbModule(module);
      rawRomLtb->setHeader(rawEventHeader);
      rawRoms.push_back(rawRomLtb);
    }else if( module->isPmtFeeModule() ){
      m_log << MSG::DEBUG << "PmtFeeModule" << endreq;
      RawRom *rawRomFee = unpackFeeModule(module);
      rawRomFee->setHeader(rawEventHeader);
      rawRoms.push_back(rawRomFee);
    }else if( module->isFlashAdcModule() ){
      //sc = this->unpackFlashAdcModule(module, readout);
    }else if( module->isRpcRomModule() ){
      //sc = this->unpackRpcRomModule(module, readout);
    }else if( module->isRpcRtmModule() ){
      //sc = this->unpackRpcRomModule(module, readout);
    }else{
      m_log << MSG::WARNING << "Cannot unpack unknown module type: " 
        << module->moduleType()<< endreq;
      sc = StatusCode::FAILURE;
    }
    if( !sc.isSuccess() ){
      // Gracefully continue even if there is trouble reading a module
      continue;
    }
    delete module;
  }

  rawEventHeader->setModules(rawRoms);

  return StatusCode::SUCCESS;
}

// Unpack the trigger data module
RawRom* RawEventHeaderCnv::unpackLtbModule(DayaBay::RawModule* module) 
{
  m_log << MSG::DEBUG << "unpackLtbModule" << endreq;

  RawRom *rawRom = new RawRomLtb();
  RawRomLtb *rawRomLtb = dynamic_cast<RawRomLtb*>(rawRom);
  rawRomLtb->setType(module->moduleType());
  rawRomLtb->setSize(module->size());
  rawRomLtb->setSlot(module->slot());

  vector<RawLtbFrame*> rawLtbFrames;
  while( DayaBay::DataFragment* fragment = module->nextDataFragment() ){
    if( fragment->isLocalTriggerData() ){
      // Process the trigger data fragment
      DayaBay::LocalTriggerData* ltbData = 
        dynamic_cast<DayaBay::LocalTriggerData*>(fragment);
      if(!ltbData){
        m_log << MSG::WARNING << "Bad Local Trigger Data fragment" << endreq;
        continue;
      }

      if(ltbData->isUnixTime()) {
        RawLtbFrameUnix *rawLtbFrame = new RawLtbFrameUnix();
        rawLtbFrames.push_back(rawLtbFrame);

        rawLtbFrame->setAccStat(ltbData->accumulationStatus());
        rawLtbFrame->setGPSValid(ltbData->gpsValid());
        rawLtbFrame->setTimestampType(ltbData->timestampType());
        rawLtbFrame->setClockSystemValid(ltbData->clockValid());
        rawLtbFrame->setRot(ltbData->readOutType());
        rawLtbFrame->setTriggerSrc(ltbData->triggerType());
        rawLtbFrame->setNanoSecondLow(ltbData->nanosecondLow());
        rawLtbFrame->setNanoSecondHigh(ltbData->nanosecondHigh());
        rawLtbFrame->setAccumulationLow(ltbData->accumulationLow());
        rawLtbFrame->setAccumulationHigh(ltbData->accumulationHigh());
        rawLtbFrame->setHsum(ltbData->hsum());
        rawLtbFrame->setEsumComp(ltbData->esumComp());
        rawLtbFrame->setEsumADC(ltbData->esum());
        rawLtbFrame->setCrossTriggerSrc(ltbData->crossTriggerSource());
        rawLtbFrame->setFeeBufferStat(ltbData->feeBufferStatus());
        rawLtbFrame->setLtbBufferStat(ltbData->ltbBufferStatus());
        rawLtbFrame->setUnixSecLow(ltbData->unixtimeLow());
        rawLtbFrame->setUnixSecHigh(ltbData->unixtimeHigh());

        TimeStamp triggerTime(ltbData->unixtime(),ltbData->nanosecond()+ltbData->accumulation());
        rawLtbFrame->setTimestamp(triggerTime);

      } // end if unix time

      else if(ltbData->isUtcTime()) {
        RawLtbFrameUTC *rawLtbFrame = new RawLtbFrameUTC();
        rawLtbFrames.push_back(rawLtbFrame);

        rawLtbFrame->setAccStat(ltbData->accumulationStatus());
        rawLtbFrame->setGPSValid(ltbData->gpsValid());
        rawLtbFrame->setTimestampType(ltbData->timestampType());
        rawLtbFrame->setClockSystemValid(ltbData->clockValid());
        rawLtbFrame->setRot(ltbData->readOutType());
        rawLtbFrame->setTriggerSrc(ltbData->triggerType());
        rawLtbFrame->setNanoSecondLow(ltbData->nanosecondLow());
        rawLtbFrame->setNanoSecondHigh(ltbData->nanosecondHigh());
        rawLtbFrame->setAccumulationLow(ltbData->accumulationLow());
        rawLtbFrame->setAccumulationHigh(ltbData->accumulationHigh());
        rawLtbFrame->setHsum(ltbData->hsum());
        rawLtbFrame->setEsumComp(ltbData->esumComp());
        rawLtbFrame->setEsumADC(ltbData->esum());
        rawLtbFrame->setCrossTriggerSrc(ltbData->crossTriggerSource());
        rawLtbFrame->setFeeBufferStat(ltbData->feeBufferStatus());
        rawLtbFrame->setLtbBufferStat(ltbData->ltbBufferStatus());
        rawLtbFrame->setDay(ltbData->days());
        rawLtbFrame->setHour(ltbData->hour());
        rawLtbFrame->setMinute(ltbData->minute());
        rawLtbFrame->setSecond(ltbData->second());
      }
    }
    delete fragment;
  }

  rawRomLtb->setFrames(rawLtbFrames);
  return rawRom;
}

// Unpack the front-end electronics data module
RawRom* RawEventHeaderCnv::unpackFeeModule(DayaBay::RawModule* module)
{
  m_log << MSG::DEBUG << "unpackFeeModule" << endreq;

  RawRom *rawRom = new RawRomFee();
  RawRomFee *rawRomFee = dynamic_cast<RawRomFee*>(rawRom);
  rawRomFee->setType(module->moduleType());
  rawRomFee->setSize(module->size());
  rawRomFee->setSlot(module->slot());
  FeeHeadFragment *headFragment = dynamic_cast<FeeHeadFragment*>(module->headFragment());
  rawRomFee->setTriggerNum(headFragment->triggerNumber());
  //rawRomFee->setTriggerType(romFee->m_triggerType);
  rawRomFee->setStatus(headFragment->status());
  //rawRomFee->setDataLength(romFee->m_dataLength);
  rawRomFee->setVersion(headFragment->feeDataVersion());

  vector<RawPmtChannel*> rawPmtChannels;
  int preChannel = -1;
  vector<int> adc,adcRange,adcCycle,tdc,tdcHitCount,pedestal;
  RawPmtChannel *rawPmtChannel = 0;
  while( DayaBay::DataFragment* fragment = module->nextDataFragment() ){
    if( fragment->isFeePeakData() ){
      // Process the FEE peak-finding data fragment
      DayaBay::FeePeakData* feePeakData = 
        dynamic_cast<DayaBay::FeePeakData*>(fragment);
      if(!feePeakData){
        m_log << MSG::WARNING << "Bad FEE Peak-finding Data fragment" << endreq;
        continue;
      }

      m_log << MSG::DEBUG << "(Slot,channel) = (" << module->slot()
        << "," << feePeakData->channel() << ")" << endreq;
      if(feePeakData->channel() != preChannel) {
        // Set previous channel
        if(preChannel != -1) {
          rawPmtChannel->setTdc(tdc);
          rawPmtChannel->setTdcHitCount(tdcHitCount);
          rawPmtChannel->setAdc(adc);
          rawPmtChannel->setAdcRange(adcRange);
          rawPmtChannel->setAdcPeakingCycle(adcCycle);
          rawPmtChannel->setPedestal(pedestal);
        }

        preChannel = feePeakData->channel();
        // new channel
        rawPmtChannel = new RawPmtChannel();
        rawPmtChannels.push_back(rawPmtChannel);
        rawPmtChannel->setChannel(feePeakData->channel());
        adc.clear();
        adcRange.clear();
        adcCycle.clear();
        tdc.clear();
        tdcHitCount.clear();
        pedestal.clear();
      }

      tdc.push_back( feePeakData->tdc() );
      tdcHitCount.push_back( feePeakData->tdcHitCount() );
      adc.push_back( feePeakData->adc() );
      adcRange.push_back(feePeakData->adcRange());
      adcCycle.push_back( feePeakData->peakCycle() );
      if( feePeakData->hasAdcPedestal() )
        pedestal.push_back( feePeakData->adcPedestal() ); 

    }else{
      m_log << MSG::WARNING << "Unknown FEE data fragment type: " << fragment->dataType() 
        << endreq;
    }
    delete fragment;
  }

  if(rawPmtChannel) {
    rawPmtChannel->setTdc(tdc);
    rawPmtChannel->setTdcHitCount(tdcHitCount);
    rawPmtChannel->setAdc(adc);
    rawPmtChannel->setAdcRange(adcRange);
    rawPmtChannel->setAdcPeakingCycle(adcCycle);
    rawPmtChannel->setPedestal(pedestal);
  }

  rawRomFee->setChannels(rawPmtChannels);
  return rawRom;
}

---