In This Package:

RawReadoutHeaderCnv.cc

Go to the documentation of this file.

#include <cstring>  // for memcpy()
#include "GaudiKernel/RegistryEntry.h"

#include "Event/ReadoutHeader.h"
#include "Event/ReadoutPmtChannel.h"
#include "Event/ReadoutPmtCrate.h"
#include "Event/ReadoutRpcCrate.h"
#include "RawData/RawData.h"

#include "RawDataIO/IRawDataInputSvc.h"
#include "RawDataAddress.h"
#include "RawDataEvent.h"
#include "RawDataIO/RawReadoutHeaderCnv.h"
#include "RawDataFormat.h"

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

extern const CLID CLID_ReadoutHeaderCnv;

//______________________________________________________________________________
RawReadoutHeaderCnv::RawReadoutHeaderCnv(long /*storageType*/ , const CLID& /*clid*/ , ISvcLocator* svc)
: Converter(RAWDATA_StorageType, classID(), svc)
  , m_log(msgSvc(), "RawReadoutHeaderCnv")
{
  m_log << MSG::DEBUG << "RawReadoutHeaderCnv(long, const CLID&, ISvcLocator*)" << endreq;
}

//______________________________________________________________________________
RawReadoutHeaderCnv::RawReadoutHeaderCnv(ISvcLocator*& svc)
: Converter(RAWDATA_StorageType, classID(), svc)
  , m_log(msgSvc(), "RawReadoutHeaderCnv")
{
  m_log << MSG::DEBUG << "RawReadoutHeaderCnv(ISvcLocator*&)" << endreq;
}

//______________________________________________________________________________
RawReadoutHeaderCnv::~RawReadoutHeaderCnv()
{
  m_log << MSG::DEBUG << "~RawReadoutHeaderCnv()" << endreq;
}


//______________________________________________________________________________
StatusCode RawReadoutHeaderCnv::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 RawReadoutHeaderCnv::updateObj(IOpaqueAddress* pAddr, DataObject* pObj)
{
  m_log << MSG::DEBUG << "updateObj()" << endreq;
  return Converter::updateObj(pAddr, pObj);
}

//______________________________________________________________________________
// Create a converted object in the Transient Data Store.
StatusCode RawReadoutHeaderCnv::createObj(IOpaqueAddress* /*pAddr*/, DataObject*& pObj)
{
  m_log << MSG::DEBUG << "createObj(IOpaqueAddress*, DataObject*&)" << endreq;

  ReadoutHeader* readoutHeader = new ReadoutHeader();
  pObj = readoutHeader;

  DayaBay::Readout* readout = 0;

  if(m_inputSvc->m_inputSvcVersion==2) {
    DayaBay::RawEvent *event = m_inputSvc->currentRawEvent();
    if (event == NULL) {
      m_log << MSG::INFO << "The RawEvent returned is not valid." << endreq;
      return StatusCode::FAILURE;
    }

    // Find the trigger time
    TimeStamp triggerTime;
    StatusCode sc = this->findTriggerTime(event,triggerTime);
    if(!sc.isSuccess()){
      m_log << MSG::WARNING << "Failed to find trigger time for event: " << event->eventId()
        << endreq;
    }

    // Set the context
    Site::Site_t site = this->convertSite( event->siteId() );
    Context context(site,
        SimFlag::kData,
        triggerTime,
        (DetectorId::DetectorId_t)(event->detectorId()));

    readoutHeader->setContext(context);
    readoutHeader->setEarliest(triggerTime);
    readoutHeader->setLatest(triggerTime);

    // Construct the readout
    DayaBay::Detector detector(this->convertSite(event->siteId()),
        this->convertDetector(event->detectorId()));

    if( detector.isAD() || detector.isWaterShield() ){
      readout = new DayaBay::ReadoutPmtCrate();
    }else if( detector.detectorId() == DetectorId::kRPC){
      readout = new DayaBay::ReadoutRpcCrate();
    }else{
      m_log << MSG::ERROR << "Unknown detector: \"" << detector.detName() << "\","
        << " cannot make readout." << endreq;
      return StatusCode::FAILURE;
    }

    // Need to set detector for proper persistency
    readout->setDetector(detector);

    // Fill readout
    if(m_inputSvc->m_usePacked){
      // Packed data
      readout->setRawEvent( event->clone() );
    }

    if(m_inputSvc->m_useUnpacked){
      // Unpacked data
      sc = this->unpackEvent(event, readout);
      if( !sc.isSuccess() ){
        delete readout;
        return sc;
      }
    }

  }

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

    readoutHeader->setExecNumber(rawEvt->m_evtNum);

    readout = new DayaBay::ReadoutPmtCrate();
    ReadoutPmtCrate* readoutCrate = dynamic_cast<ReadoutPmtCrate*>(readout);
    readoutCrate->setDetector(Detector(rawEvt->siteId(), rawEvt->detectorId()));
    readoutCrate->setTriggerType(rawEvt->triggerType());

    //the following code is temporarily commented because readoutCrate doesn't have setRawEvent function
    //if( rawEvt->m_rawBuffer.size() > 0){
    //  readoutCrate->setRawEvent(
    //                     DayaBay::RawEvent( &rawEvt->m_rawBuffer[0] ).clone() );
    //}

    ReadoutPmtCrate::FadcReadouts fadcReadouts;
    for (unsigned int i = 0; i < rawEvt->m_modules.size(); i++) {
      switch (rawEvt->m_modules[i]->m_type) {
        case kRomLtb:
          RawDataEvent::RomLtb* romLtb;
          romLtb = dynamic_cast<RawDataEvent::RomLtb*>(rawEvt->m_modules[i]);
          for (unsigned int j = 0; j < romLtb->m_frames.size(); j++) {
            RawDataEvent::LtbFrame *ltbFrame = romLtb->m_frames[j];
            readoutCrate->setTriggerTime(ltbFrame->timeStamp());
            break;
          }
          break;
        case kRomFadc:
          RawDataEvent::RomFadc* romFadc;
          romFadc = dynamic_cast<RawDataEvent::RomFadc*>(rawEvt->m_modules[i]);
          for (unsigned int j = 0; j < romFadc->m_channels.size(); j++) {
            RawDataEvent::FadcChannel &channel = romFadc->m_channels[j];
            FadcChannelId channelId(channel.m_channel+1, rawEvt->siteId(), rawEvt->detectorId());
            DigitalSignal channelData=channel.m_adcData;
            fadcReadouts[channelId]=channelData;
          }
          break;
        case kRomFee:
          RawDataEvent::RomFee* romFee;
          romFee = dynamic_cast<RawDataEvent::RomFee*>(rawEvt->m_modules[i]);
          readoutCrate->setTriggerNumber(romFee->m_triggerNum);
          for (unsigned int j = 0; j < romFee->m_channels.size(); j++) {
            RawDataEvent::PmtChannel &channel = romFee->m_channels[j];
            // FeeChannelId(board, connector, site, det)
            // FEE board number in the DAQ counts from '1 to n', but the connector counts from '0 to n-1'
            FeeChannelId channelId(romFee->m_slot, channel.m_channel+1, rawEvt->siteId(), rawEvt->detectorId());
            ReadoutPmtChannel &channelData = readoutCrate->channel(channelId);

            channelData.setReadout(readoutCrate);
            channelData.setMode(0x1);  //peak finding
            channelData.setChannelId(channelId);
            channelData.setAdc(channel.m_adc);
            channelData.setAdcCycle(channel.m_adcPeakingCycle);
            vector<int> tmpGain;
            for ( unsigned int ci = 0; ci!=channel.m_adcRange.size(); ci++) {
              if ( channel.m_adcRange[ci] == dyb::kAdcHighRange ) {
                tmpGain.push_back(  FeeGain::kLow );
              } else if ( channel.m_adcRange[ci] == dyb::kAdcLowRange ) {
                tmpGain.push_back(  FeeGain::kHigh );
              }
            }
            channelData.setAdcRange( tmpGain );
            channelData.setTdc(channel.m_tdc);
            channelData.setTdcHitCount(channel.m_tdcHitCount);
            channelData.setPedestal(channel.m_pedestal);

            // insert into readout map
            //readoutChannels[channelId] = channelData;
          }
          break;
      }
    }

    //readoutCrate->setChannelReadout(readoutChannels);
    readoutCrate->setFadcReadout(fadcReadouts);
    Site::Site_t site = rawEvt->siteId();
    SimFlag::SimFlag_t flag = SimFlag::kData;
    DetectorId::DetectorId_t det = rawEvt->detectorId();
    const TimeStamp& time = readoutCrate->triggerTime();

    Context context = Context(site, flag, time, det);
    readoutHeader->setContext(context);
  }

  readout->setHeader(readoutHeader);
  readoutHeader->setReadout(readout);
 
  return StatusCode::SUCCESS;
}


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

  ReadoutHeader* rdth = dynamic_cast<ReadoutHeader*>(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 RawReadoutHeaderCnv::finalize()
{
  m_log << MSG::DEBUG << "finalize()" << endreq;
  return StatusCode::SUCCESS;
}

//______________________________________________________________________________
StatusCode RawReadoutHeaderCnv::findTriggerTime(DayaBay::RawEvent* event, 
    TimeStamp& triggerTime)
{
  // Find the trigger time for this event
  if(!event){
    m_log << MSG::ERROR << "Cannot find time of invalid event" << endreq;
    return StatusCode::FAILURE;
  }
  // Search raw data block for trigger time
  bool foundTriggerTime = false;
  while( DayaBay::RawModule* module = event->nextModule() ){
    if( module->isLocalTriggerModule() ){
      while( DayaBay::DataFragment* fragment = module->nextDataFragment() ){
        if( fragment->isLocalTriggerData() ){
          DayaBay::LocalTriggerData* ltbData = 
            dynamic_cast<DayaBay::LocalTriggerData*>(fragment);
          if(!ltbData){
            m_log << MSG::ERROR << "Failed to access local trigger data fragment" << endreq;
            return StatusCode::FAILURE;
          }
          triggerTime = this->convertTriggerTime(ltbData);
          foundTriggerTime = true;
          break;
        }
        delete fragment;
      }
      if( foundTriggerTime ) break;
    }
    delete module;
  }
  event->resetModule();
  if(!foundTriggerTime)   return StatusCode::FAILURE;
  return StatusCode::SUCCESS;
}


TimeStamp RawReadoutHeaderCnv::convertTriggerTime(DayaBay::LocalTriggerData* ltbData)
{
  //Unpack Trigger time from raw LTB data block
  TimeStamp triggerTime;
  if(ltbData->isUnixTime()){
    triggerTime = TimeStamp(ltbData->unixtime(),
        ltbData->nanosecond()+ltbData->accumulation());
  }else if(ltbData->isUtcTime()){
    // This data format provides no 'year'
    // Estimate the year from the file start time
    if(  ltbData->days()  <  m_inputSvc->m_utcDay ){
      // Catch case where file spans new year
      m_inputSvc->m_fileYear++;
    }
    triggerTime = TimeStamp(m_inputSvc->m_fileYear,
        1 /*month*/,
        ltbData->days()+1 /*day in year*/,
        ltbData->hour(),
        ltbData->minute(),
        ltbData->second(),
        ltbData->nanosecond()+ltbData->accumulation(),
        true /*UTC*/);
    m_inputSvc->m_utcDay = ltbData->days();
  }else{
    // Date format from LTB Data version 0
    // The trigger times in m_inputSvc format have many issues; see DocDB-4635
    // Override using the file start time
    // Fix bug caused by 61s in a minute and 61m in an hour
    unsigned int seconds = ltbData->hour()*61*61 
      + ltbData->minute()*61 
      + ltbData->second();
    unsigned int hour = seconds / 3600;
    unsigned int minute = (seconds - hour*3600) / 60;
    unsigned int second = (seconds - (hour*3600 + minute*60));
    int timezoneOffset = -8*60*60; /* 8hr offset of PRC from UTC */
    triggerTime = TimeStamp(m_inputSvc->m_fileYear,  //ltbData->year(),
        m_inputSvc->m_fileMonth, //ltbData->month(),
        m_inputSvc->m_fileDay,   //ltbData->day(),
        hour,
        minute,
        second,
        (int)(ltbData->clock()*12.5) /* 80MHz clock */,
        true /*use UTC with timezone offset*/,
        timezoneOffset);
  }
  return triggerTime;
}

Site::Site_t RawReadoutHeaderCnv::convertSite(unsigned int daqSiteId)
{
  // Convert site definition from DAQ to Offline convention 
  switch(daqSiteId){
    case 1:
      return Site::kDayaBay;
    case 2:
      return Site::kLingAo;
    case 3:
      return Site::kFar;
    case 4:
      return Site::kMid;
    case 6:
      return Site::kSAB;
    default:
      break;
  }
  return Site::kUnknown;
}

DetectorId::DetectorId_t RawReadoutHeaderCnv::convertDetector(
    unsigned int daqDetectorId)
{
  // Convert detector definition from DAQ to Offline convention 
  switch(daqDetectorId){
    case 1:
      return DetectorId::kAD1;
    case 2:
      return DetectorId::kAD2;
    case 3:
      return DetectorId::kAD3;
    case 4:
      return DetectorId::kAD4;
    case 5:
      return DetectorId::kIWS;
    case 6:
      return DetectorId::kOWS;
    case 7:
      return DetectorId::kRPC;
    default:
      break;
  }
  return DetectorId::kUnknown;
}

int RawReadoutHeaderCnv::convertBoard(unsigned int daqSlotId)
{
  return daqSlotId;
}

int RawReadoutHeaderCnv::convertConnector(unsigned int daqChannelId)
{
  return daqChannelId+1;
}

DayaBay::Trigger::TriggerType_t RawReadoutHeaderCnv::convertTriggerType(
    DayaBay::LocalTriggerData* ltbData,
    const DayaBay::Detector* detector)
{
  // Convert Online trigger type to Offline convention
  unsigned int triggerType = DayaBay::Trigger::kUnknown;
  if(ltbData->isManualTrigger())
    triggerType |= DayaBay::Trigger::kManual;
  if(ltbData->isCrossTrigger())
    triggerType |= DayaBay::Trigger::kCross;
  if(ltbData->isPeriodicTrigger())
    triggerType |= DayaBay::Trigger::kPeriodic;
  if(ltbData->isMultiplicityTrigger())
    triggerType |= DayaBay::Trigger::kMult;
  // FIXME: Need to add all Esum trigger types to offline convention
  if(ltbData->isEsumAdcTrigger())
    triggerType |= DayaBay::Trigger::kESum;
  if(ltbData->isEsumCompHighTrigger())
    triggerType |= DayaBay::Trigger::kESum;
  if(ltbData->isEsumCompLowTrigger())
    triggerType |= DayaBay::Trigger::kESum;
  if(ltbData->isEsumCompAllTrigger())
    triggerType |= DayaBay::Trigger::kESum;

  switch(detector->detectorId()){
    case DetectorId::kAD1:
      triggerType |= DayaBay::Trigger::kAD1;
      break;
    case DetectorId::kAD2:
      triggerType |= DayaBay::Trigger::kAD2;
      break;
    case DetectorId::kAD3:
      triggerType |= DayaBay::Trigger::kAD3;
      break;
    case DetectorId::kAD4:
      triggerType |= DayaBay::Trigger::kAD4;
      break;
    case DetectorId::kIWS:
      triggerType |= DayaBay::Trigger::kIWS;
      break;
    case DetectorId::kOWS:
      triggerType |= DayaBay::Trigger::kOWS;
      break;
    default:
      break;
  }

  return static_cast<DayaBay::Trigger::TriggerType_t>(triggerType);
}

DayaBay::FeeGain::FeeGain_t RawReadoutHeaderCnv::convertAdcRange(
    unsigned int daqAdcRange)
{
  // Convert ADC Range definition from DAQ to Offline convention 
  switch(daqAdcRange){
    case 0:
      return DayaBay::FeeGain::kHigh;
    case 1:
      return DayaBay::FeeGain::kLow;
    default:
      break;
  }
  return DayaBay::FeeGain::kUnknown;
}


StatusCode RawReadoutHeaderCnv::unpackEvent(DayaBay::RawEvent* event, 
    DayaBay::Readout* readout)
{
  // Unpack raw data into readout object

  // Loop over modules
  while( DayaBay::RawModule* module = event->nextModule() ){
    StatusCode sc;
    if( module->isLocalTriggerModule() ){
      sc = this->unpackLtbModule(module, readout);
    }else if( module->isPmtFeeModule() ){
      sc = this->unpackFeeModule(module, 
          dynamic_cast<DayaBay::ReadoutPmtCrate*>(readout));
    }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;
  }

  return StatusCode::SUCCESS;
}

StatusCode RawReadoutHeaderCnv::unpackLtbModule(DayaBay::RawModule* module, 
    DayaBay::Readout* readout)
{
  // Unpack the trigger data module
  bool firstTriggerFragment = true;
  TimeStamp triggerTime;

  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;
      }
      triggerTime = this->convertTriggerTime(ltbData);
      if(firstTriggerFragment){
        // Set trigger time, type, number according to first trigger data block
        readout->setTriggerTime( triggerTime );
        readout->setTriggerType(this->convertTriggerType(ltbData, 
              &(readout->detector())));
        // Get Trigger Number from head fragment
        DayaBay::HeadFragment* headFragment = module->headFragment();
        if( headFragment ){
          readout->setTriggerNumber( headFragment->triggerNumber() );
          delete headFragment;
        }else{
          m_log << MSG::WARNING << "Missing head fragment!" << endreq;
        }
        firstTriggerFragment = false;
      }else{
        if(triggerTime != readout->triggerTime()){
          TimeStamp dtTrigger( triggerTime );
          dtTrigger.Subtract( readout->triggerTime() );
          m_log << MSG::DEBUG << "Additional trigger at dT = " <<  dtTrigger.GetSeconds()
            << " [s]" << endreq;
        }
      }
    }else{
      m_log << MSG::WARNING << "Unknown LTB data fragment type: " << fragment->dataType() 
        << endreq;
    }
    delete fragment;
  }
  return StatusCode::SUCCESS;
}

StatusCode RawReadoutHeaderCnv::unpackFeeModule(DayaBay::RawModule* module, 
    DayaBay::ReadoutPmtCrate* readout)
{
  // Unpack the front-end electronics data module
  if(!readout){
    m_log << MSG::WARNING << "Trying to add FEE data to a non-PMT readout"
      << endreq;
    return StatusCode::FAILURE;
  }

  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;
      }
      // Add channel data to readout
      DayaBay::FeeChannelId channelId(
          this->convertBoard(module->slot()),
          this->convertConnector(feePeakData->channel()),
          readout->detector().site(),
          readout->detector().detectorId()); 

      DayaBay::ReadoutPmtChannel& feeChannel = readout->channel(channelId);
      if(feeChannel.channelId() != channelId){
        // New channel, initialize
        feeChannel.setChannelId(channelId);
        feeChannel.setMode(0x1); // Peak-finding
        feeChannel.setReadout(readout);
      }
      // Add hit data
      feeChannel.tdc().push_back( feePeakData->tdc() );
      feeChannel.tdcHitCount().push_back( feePeakData->tdcHitCount() );
      feeChannel.adc().push_back( feePeakData->adc() );
      feeChannel.adcRange().push_back( 
          this->convertAdcRange(feePeakData->adcRange()) );
      feeChannel.adcCycle().push_back( feePeakData->peakCycle() );
      if( feePeakData->hasAdcPedestal() )
        feeChannel.pedestal().push_back( feePeakData->adcPedestal() ); 
    }else{
      m_log << MSG::WARNING << "Unknown FEE data fragment type: " << fragment->dataType() 
        << endreq;
    }
    delete fragment;
  }
  return StatusCode::SUCCESS;
}

---