In This Package:

RawDataInputSvc.cc

Go to the documentation of this file.

#include <cstring>  // for memcpy()

#include "GaudiKernel/MsgStream.h"
#include "RawDataInputSvc.h"
//from DBI
#include "DbiRawDataFileSvc/DaqRawDataFileInfo.h"
#include "DatabaseInterface/DbiResultPtr.h"
// Two type of input stream .data and .rraw
#include "RawData/IFStream.h"
#include "RawData/RRawStream.h"
#include "RawData/RawRecord.h"
#include "CLHEP/Random/RandFlat.h"

using namespace std;
using namespace dyb;

//______________________________________________________________________________
RawDataInputSvc::RawDataInputSvc(const string& name, ISvcLocator* svcloc)
  : Service(name, svcloc), 
    m_inputStream(0),
    m_rawDataEvent(0),
    m_bufferSize(0),
    m_buffer(0),
    m_printFreq(0),
    m_isFileHeaderPrinted(false),
    m_includeRawEvent(false),
    m_randomEvtNum(0),
    m_SeqNo(0),
    m_IsDBI(false),
    m_reader(0)
{
   //MsgStream log(msgSvc(), name());
   //log << MSG::DEBUG << "RawDataInputSvc()" << endreq;
   m_rawDataEvent = new RawDataEvent();
   declareProperty("RawDataFiles", m_inputFiles, "list of raw data files for input");
   declareProperty("PrintFreq", m_printFreq = 100, "print frequency for event information");
   declareProperty("IfRawEventHeader", m_ifRawEventHeader = false, "Whether created RawEventHeader");
   declareProperty("SeqNo", m_SeqNo= 1, " the initial Number of SeqNo uesed by DBI");
   declareProperty("IsDBI", m_IsDBI= false," Turn on/off geting raw data file from DBI");
   declareProperty("IncludeRawEvent", m_includeRawEvent= false,
                   " Copy the full raw data block to the transient event?");
   declareProperty("SamplingInterval", m_samplingInterval= 1, "sampling interval"); 
   declareProperty("InputSvcVersion",m_inputSvcVersion=1,"RawDataInputSvc version");
   declareProperty("UsePacked",m_usePacked=false,"Load Packed Data");
   declareProperty("UseUnpacked",m_useUnpacked=true,"Load Unpacked Data");

}

RawDataInputSvc::~RawDataInputSvc()
{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "~RawDataInputSvc()" << endreq;
  delete m_rawDataEvent;
}

//______________________________________________________________________________
StatusCode RawDataInputSvc::initialize()
{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "initialize()" << endreq;

  StatusCode sc = Service::initialize();
  if (sc.isFailure()) {
    log << MSG::ERROR << "parent class failed to initialize" << endreq;
    return sc;
  }

  if (!m_IsDBI && m_inputFiles.size() == 0 ) {
    log << MSG::ERROR << " ==> No raw data files defined for this job!!" << endreq;
  } else if (!m_IsDBI ) {
    log << MSG::INFO << " ==> there are [" << m_inputFiles.size() << "] raw data files pre-defined." << endreq;
  } else {
    log << MSG::INFO << " ==> raw data files to be read will be queried from database. "<<endreq;
  }

  // check file suffix based on the first file.
  string fname = m_inputFiles[0];
  string suffix = fname.substr(fname.size()-5,5);

  if( suffix==".data" ) { 
    m_inputStream = new IFStream; 
    log << MSG::INFO << "Using IFStream for input" << endreq;
  }
  else if ( suffix==".rraw" ) {
    m_inputStream = new RRawStream; 
    log << MSG::INFO << "Using RRawStream for input" << endreq;
  }

  // opening raw data file
  sc = nextInputFile();
  return sc;
}


//______________________________________________________________________________
StatusCode RawDataInputSvc::finalize()
{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "finalize()" << endreq;
  if (m_inputStream->is_open())
    m_inputStream->close();

  if (m_buffer != 0) delete[] m_buffer;

  return this->Service::finalize();
}

//______________________________________________________________________________
StatusCode RawDataInputSvc::queryInterface(const InterfaceID& riid, void** ppRaw)
{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "queryInterface(" << riid.id() << "." << riid.majorVersion() << "." << riid.minorVersion() << ")" << endreq;
  if (IID_IRawDataInputSvc.versionMatch(riid)) {
    log << MSG::DEBUG << "--> IRawDataInputSvc" << endreq;
    *ppRaw = dynamic_cast<IRawDataInputSvc*>(this);
    return StatusCode::SUCCESS;
  } else {
    log << MSG::DEBUG << "---> other" << endreq;
  }
  return Service::queryInterface(riid, ppRaw);
}


//______________________________________________________________________________
StatusCode RawDataInputSvc::nextInputFile()
{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "nextInputFile()" << endreq;

  if(m_inputSvcVersion==2) {
    // Delete old file reader
    if(m_reader){
      delete m_reader;
      m_reader=0;
    }
  }

  m_isFileHeaderPrinted = false;

  static unsigned int i = 0;
  if ( i >= m_inputFiles.size() ) {
    if ( !m_IsDBI ) {
      log << MSG::WARNING << "no more raw data file." << endreq;
      return StatusCode::FAILURE;
    } else  {
      if(  queryRawFileFromDB() > 0 ) {
        i=0;
        nextInputFile();
      } else{
        //need more considering based on SeqNo.
        //........................
        log << MSG::WARNING << "no more raw data file." << endreq;
        return StatusCode::FAILURE;
      }  
    } 
  }

  if(m_inputSvcVersion==2) {
    // Create new file reader
    m_reader = new DayaBay::RawDataReader;
    if(!m_reader){
      log << MSG::ERROR << "Failed to create new file reader" << endreq;
      return StatusCode::FAILURE;
    }

    if(!m_reader->open( m_inputFiles[i].c_str() )){
      log << MSG::ERROR << "Failed to open input file: " << m_inputFiles[i]
        << endreq;
      delete m_reader;
      m_reader=0;
      return StatusCode::FAILURE;
    }
  }

  // close the input stream if it's open
  if (m_inputStream->is_open()) m_inputStream->close();

  string fn = m_inputFiles[i++];
  m_inputStream->open(fn.c_str());
  if (!m_inputStream->good()) {
    log << MSG::ERROR << "Failed opening the raw data file: " << fn << endreq;      return StatusCode::FAILURE;
  }

  log << MSG::INFO << "Success opening the raw data file: " << fn << endreq;
  return StatusCode::SUCCESS;
}


//______________________________________________________________________________
RawDataEvent*  RawDataInputSvc::currentEvent()
{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "currentEvent()" << endreq;
  return  m_rawDataEvent;
}


//______________________________________________________________________________
DayaBay::RawEvent*  RawDataInputSvc::currentRawEvent()
{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "currentRawEvent()" << endreq;
  return  m_rawEvent;
}


//______________________________________________________________________________
DayaBay::RawEvent*  RawDataInputSvc::currentRawEventClone()
{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "currentRawEventClone()" << endreq;
  return  m_rawEventClone;
}


//______________________________________________________________________________
StatusCode  RawDataInputSvc::nextEvent()
{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "nextEvent()" << endreq;

  StatusCode sc = StatusCode::SUCCESS;


  if(m_inputSvcVersion==2) {
    DayaBay::RawEvent* event = 0;
    while( !event ){

      DayaBay::RawRecord* record = m_reader->nextRecord();
      if(!record){
        log << MSG::ERROR << "Failed to read next record" << endreq;
        return StatusCode::FAILURE;
      }

      log << MSG::DEBUG << "Record type: 0x" << hex << record->type() << dec << endreq;

      if( !record->isDataSeparator() ){
        std::stringstream message;
        record->dump( message );
        log << MSG::INFO << message.str() << endreq;
        if( record->isFileStart() ){
          DayaBay::RawFileStart* fileStart = dynamic_cast<DayaBay::RawFileStart*>(record);
          if(fileStart){
            m_fileYear = fileStart->date() % 10000;
            m_fileMonth = (fileStart->date() / 10000) % 100;
            m_fileDay = (fileStart->date() / 1000000) % 100;
            m_utcDay = 0;
          }
        }
        if( record->isFileEnd() ){
          //End of file.
          sc = nextInputFile();
          if(sc != StatusCode::SUCCESS) {
            delete record;
            return sc;
          }
          //delete m_reader;
          //m_reader = 0; 
        }
        delete record;
        continue;
      }

      DayaBay::RawDataSeparator* dataSeparator =
        dynamic_cast<DayaBay::RawDataSeparator*>(record);
      if( !dataSeparator ){
        log << MSG::ERROR << "Failed to process data separator" << endreq;
        std::stringstream message;
        record->dump( message );
        log << MSG::ERROR << message.str() << endreq;
        delete record;
        return StatusCode::FAILURE;
      }

      DayaBay::RawData* data = dataSeparator->data();
      if( !data ){
        log << MSG::ERROR << "Failed to load payload data" << endreq;
        std::stringstream message;
        record->dump( message );
        log << MSG::ERROR << message.str() << endreq;
        delete record;
        return StatusCode::FAILURE;
      }

      if( !data->isEventType() ){
        std::stringstream message;
        data->dump( message );
        log << MSG::INFO << message.str() << endreq;
        delete data;
        delete record;
        return sc;
      }

      event = dynamic_cast<DayaBay::RawEvent*>(data);
      if( !event ){
        log << MSG::ERROR << "Failed to read event" << endreq;
        std::stringstream message;
        data->dump( message );
        log << MSG::ERROR << message.str() << endreq;
        delete data;
        delete record;
        return StatusCode::FAILURE;
      }

      // data sampling
      if(event->eventId() % m_samplingInterval != 0) {
        event = 0;
        delete data;
        delete record;
        continue;
      }

      m_rawEvent = event;
      if(m_ifRawEventHeader) m_rawEventClone = m_rawEvent->clone();
    }
  }

  else {
    // read next record from the file stream, and return the record marker.
    uint32_t recordMarker = nextRecord();

    //check the record marker, decode the record and decide work flow accordingly.
    switch (recordMarker) {
      case kFileStartRecord:
      case kFileNameStrings:
      case kMetadataStrings:
      case kRunParametersRecord:
      case kCalibrationParametersRecord:
        sc = nextEvent();
        break;
      case kDataSeparatorRecord: // event data record
        sc = StatusCode::SUCCESS;
        break;
      case kFileEndRecord:
        sc = nextInputFile();
        if (sc.isSuccess()) {
          sc = nextEvent();
        }
        break;
      default:
        log << MSG::WARNING << "unknown recordMarker=" << hex << recordMarker << endreq;
        sc = StatusCode::FAILURE;
        break;
    }
  }

  return sc;
}


//______________________________________________________________________________
uint32_t  RawDataInputSvc::nextRecord()
{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "nextRecord()" << endreq;

  uint32_t temp, recordMarker, recordSize;
  unsigned int readSize = 0; // size has been read in 4bytes

  // read record marker
  m_inputStream->read((char*)(&temp), 4);
  recordMarker = temp;
  readSize++;
  // read record size
  m_inputStream->read((char*)(&temp), 4);
  recordSize = temp; // in 4*bytes
  readSize++;
  log << MSG::DEBUG << "  recordMarker=0x" << hex << recordMarker << " recordSize=" << dec << recordSize << "*4 bytes" << endreq;
  // read record data
  switch (recordMarker) {
    case kFileStartRecord:
      log << MSG::DEBUG << "kFileStartRecord" << endreq;
      m_inputStream->read((char*)(&temp), 4);
      m_rawDataEvent->m_fileHeader->m_version = temp;
      readSize++;
      m_inputStream->read((char*)(&temp), 4);
      m_rawDataEvent->m_fileHeader->m_fileNumber = temp;
      readSize++;
      m_inputStream->read((char*)(&temp), 4);
      m_rawDataEvent->m_fileHeader->m_date = temp;
      readSize++;
      m_inputStream->read((char*)(&temp), 4);
      m_rawDataEvent->m_fileHeader->m_time = temp;
      readSize++;
      m_inputStream->read((char*)(&temp), 4);
      m_rawDataEvent->m_fileHeader->m_sizeLimitBlocks = temp;
      readSize++;
      m_inputStream->read((char*)(&temp), 4);
      m_rawDataEvent->m_fileHeader->m_sizeLimitMB = temp;
      readSize++;
      break;
    case kFileNameStrings:
      log << MSG::DEBUG << "kFileNameStrings" << endreq;
      int length, padding;

      // appName
      m_inputStream->read((char*)(&temp), 4);
      length = temp;
      readSize++;
      m_rawDataEvent->m_fileHeader->m_appName.clear();
      for (int i = 0; i < length; i++) {
        char ctemp;
        m_inputStream->read(&ctemp, 1);
        m_rawDataEvent->m_fileHeader->m_appName.append(1, ctemp);
      }
      padding = length % 4;
      if (padding > 0) {
        padding = 4 - padding;
        m_inputStream->read((char*)(&temp), padding);
      }
      readSize += (length + padding) / 4;

      // fileNameTag
      m_inputStream->read((char*)(&temp), 4);
      length = temp;
      readSize++;
      m_rawDataEvent->m_fileHeader->m_fileNameTag.clear();
      for (int i = 0; i < length; i++) {
        char ctemp;
        m_inputStream->read(&ctemp, 1);
        m_rawDataEvent->m_fileHeader->m_fileNameTag.append(1, ctemp);
      }
      padding = length % 4;
      if (padding > 0) {
        padding = 4 - padding;
        m_inputStream->read((char*)(&temp), padding);
      }
      readSize += (length + padding) / 4;

      break;
    case kMetadataStrings:
      log << MSG::DEBUG << "kMetadataStrings" << endreq;
      m_inputStream->read((char*)(&temp), 4);
      int nstr;
      nstr = temp;
      readSize++;
      m_rawDataEvent->m_fileHeader->m_metadataString.clear();
      for (int j = 0; j < nstr; j++) {
        m_inputStream->read((char*)(&temp), 4);
        length = temp;
        readSize++;
        string str;
        for (int i = 0; i < length; i++) {
          char ctemp;
          m_inputStream->read(&ctemp, 1);
          str.append(1, ctemp);
        }
        m_rawDataEvent->m_fileHeader->m_metadataString.push_back(str);

        padding = length % 4;
        if (padding > 0) {
          padding = 4 - padding;
          m_inputStream->read((char*)(&temp), padding);
        }
        readSize += (length + padding) / 4;
      }
      break;
    case kRunParametersRecord:
      m_inputStream->read((char*)(&temp), 4);
      m_rawDataEvent->m_fileHeader->m_runNumber = temp;
      readSize++;
      m_inputStream->read((char*)(&temp), 4);
      m_rawDataEvent->m_fileHeader->m_recEnable = temp;
      readSize++;
      m_inputStream->read((char*)(&temp), 4);
      m_rawDataEvent->m_fileHeader->m_triggerType = temp;
      readSize++;
      m_inputStream->read((char*)(&temp), 4);
      m_rawDataEvent->m_fileHeader->m_detectorMask = temp;
      readSize++;
      break;
    case kCalibrationParametersRecord:
      // offline should find a place to record calibration parameters
      // may be RunData, but it needs to be consistent with raw data
      m_inputStream->ignore((recordSize - 2)*4);
      readSize += recordSize - 2;
      break;
    case kDataSeparatorRecord: // event data record
      log << MSG::DEBUG << "kDataSeparatorRecord" << endreq;
      m_inputStream->read((char*)(&temp), 4);
      m_rawDataEvent->m_dataBlockNum = temp;
      readSize++;
      m_inputStream->read((char*)(&temp), 4);
      m_rawDataEvent->m_dataBlockSize = temp; // in bytes
      readSize++;
      log << MSG::DEBUG << " m_dataBlockNum = " << m_rawDataEvent->m_dataBlockNum 
        << ", m_dataBlockSize = " << m_rawDataEvent->m_dataBlockSize << endreq;


      if(m_rawDataEvent->m_dataBlockNum % m_samplingInterval != 0) {
        m_inputStream->ignore(m_rawDataEvent->m_dataBlockSize);
        // temporarily return kMetadataStrings to skip this event
        recordMarker = kMetadataStrings;
      } else {
        // read the following event data block into buffer
        setBuffer(m_rawDataEvent->m_dataBlockSize);
        m_inputStream->read(m_buffer, m_rawDataEvent->m_dataBlockSize);

        readRawEventBuffer();
      }
      break;
    case kFileEndRecord:
      log << MSG::DEBUG << "kFileEndRecord" << endreq;
      m_inputStream->read((char*)(&temp), 4);
      m_rawDataEvent->m_fileFooter->m_dateEnd = temp;
      readSize++;
      m_inputStream->read((char*)(&temp), 4);
      m_rawDataEvent->m_fileFooter->m_timeEnd = temp;
      readSize++;
      m_inputStream->read((char*)(&temp), 4);
      m_rawDataEvent->m_fileFooter->m_eventsInFile = temp;
      readSize++;
      m_inputStream->read((char*)(&temp), 4);
      m_rawDataEvent->m_fileFooter->m_dataInFile = temp;
      readSize++;
      m_inputStream->read((char*)(&temp), 4);
      m_rawDataEvent->m_fileFooter->m_eventsInRun = temp;
      readSize++;
      m_inputStream->read((char*)(&temp), 4);
      m_rawDataEvent->m_fileFooter->m_dataInRun = temp;
      readSize++;
      m_inputStream->read((char*)(&temp), 4);
      m_rawDataEvent->m_fileFooter->m_status = temp;
      readSize++;
      m_inputStream->read((char*)(&temp), 4);
      uint32_t endMarker;
      endMarker = temp;
      readSize++;
      if (endMarker != kFileEndMarker) {
        log << MSG::WARNING << "file end marker wrong"
          << " expected=0x" << hex << kFileEndMarker
          << " real=0x" << endMarker
          << dec << endreq;
      }
      m_rawDataEvent->m_fileFooter->print();
      break;
    default:
      log << MSG::WARNING << "unknown recordMarker=0x" << hex << recordMarker << dec << endreq;
      break;
  }

  // check consistency
  if (readSize != recordSize) {
    log << MSG::WARNING << "read size NOT equal to record size:"
      << " recordMarker=0x" << hex << recordMarker << dec
      << " recordSize=" << recordSize
      << " readSize=" << readSize
      << endreq;

    // skip left bytes
    if (readSize < recordSize) {
      m_inputStream->ignore((recordSize - readSize)*4);
    }
  }

  return recordMarker;
}


//______________________________________________________________________________
void RawDataInputSvc::readRawEventBuffer()
{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "readRawEventBuffer()" << endreq;

  uint32_t temp;
  uint32_t headerMarker;
  int offset = 0;
  m_rawDataEvent->clear();
  while (offset < m_bufferSize) {
    memcpy(&temp, m_buffer + offset, 4);
    offset += 4;
    headerMarker = temp;
    log << MSG::VERBOSE << offset - 4 << ": headerMarker=0x" << hex << headerMarker << dec << endreq;
    if (headerMarker == kEventHeader) {
      // format version
      memcpy(&temp, m_buffer + offset, 4);
      offset += 4;
      m_rawDataEvent->m_formatVersionMajor = get_bits(temp, 24, 8);
      m_rawDataEvent->m_formatVersionMinor = get_bits(temp, 16, 8);
      // size information
      memcpy(&temp, m_buffer + offset, 4);
      offset += 4;
      m_rawDataEvent->m_evtSize = get_bits(temp, 0, 24) * 4;
      if( m_includeRawEvent ){
        // Include full raw event if requested
        m_rawDataEvent->m_rawBuffer.resize( m_rawDataEvent->m_evtSize );
        memcpy(&(m_rawDataEvent->m_rawBuffer[0]),
            (unsigned int*)(m_buffer+offset-3*4),
            m_rawDataEvent->m_evtSize);
      }
      // source identifier
      memcpy(&temp, m_buffer + offset, 4);
      offset += 4;
      //m_rawDataEvent->m_detType = get_bits(temp, 4, 4);
      m_rawDataEvent->m_detId   = get_bits(temp, 16, 8);
      m_rawDataEvent->m_positionId  = get_bits(m_rawDataEvent->m_detId, 0, 4);
      m_rawDataEvent->m_siteId   = get_bits(m_rawDataEvent->m_detId, 4, 4);
      // run number
      memcpy(&temp, m_buffer + offset, 4);
      offset += 4;
      m_rawDataEvent->m_runNum = temp;
      // event Id
      memcpy(&temp, m_buffer + offset, 4);
      offset += 4;
      m_rawDataEvent->m_evtNum = temp;
      // detector data type
      memcpy(&temp, m_buffer + offset, 4);
      offset += 4;
      m_rawDataEvent->m_dataType  = get_bits(temp, 28, 4);
      m_rawDataEvent->m_dataTypeSpecific = get_bits(temp, 0, 16);
      // data status
      memcpy(&temp, m_buffer + offset, 4);
      offset += 4;
      m_rawDataEvent->m_dataStatus = temp;
      // end of the Event Header
    } else if (headerMarker == kROMHeader) {
      int romRead = 4;  // bytes read
      // ROM fragment size
      memcpy(&temp, m_buffer + offset, 4);
      offset += 4;
      romRead += 4;
      int romSize = get_bits(temp, 0, 24) * 4;
      int romDataSize = romSize - get_bits(temp, 24, 8) * 4;
      // module identifier
      memcpy(&temp, m_buffer + offset, 4);
      offset += 4;
      romRead += 4;
      int romSlot = get_bits(temp, 0, 8);
      int romType = get_bits(temp, 8, 8);

      log << MSG::DEBUG << "runNum=" << m_rawDataEvent->m_runNum << " evtNum=" << m_rawDataEvent->m_evtNum << " RomType=" << romType << " romDataSize = " << romDataSize << endreq;

      // read different ROM types
      RawDataEvent::Rom* rom;
      switch (romType) {
        case kRomFee:
          rom = new RawDataEvent::RomFee();
          romRead += readRomData(dynamic_cast<RawDataEvent::RomFee*>(rom), offset, romDataSize);
          break;
        case kRomFadc:
          rom = new RawDataEvent::RomFadc();
          romRead += readRomData(dynamic_cast<RawDataEvent::RomFadc*>(rom), offset, romDataSize);
          break;
        case kRomLtb:
          rom = new RawDataEvent::RomLtb();
          romRead += readRomData(dynamic_cast<RawDataEvent::RomLtb*>(rom), offset, romDataSize);
          break;
        default:
          break;
      }

      rom->m_size = romSize;
      rom->m_slot = romSlot;
      rom->m_type = romType;
      m_rawDataEvent->m_modules.push_back(rom);

      if (romRead != rom->m_size) {
        log << MSG::WARNING << "ROM size=" << rom->m_size << ", read=" << romRead << endreq;
      }

    } else {
      log << MSG::WARNING << "something is wrong or end of buffer!" << endreq;
      log << MSG::WARNING << "  headerMarker=" << hex << headerMarker << dec << endreq;
      log << MSG::WARNING << "  offset=" << offset << endreq;
      log << MSG::WARNING << "  m_bufferSize=" << m_rawDataEvent->m_dataBlockSize << endreq;
      break;
    }
  }
  printEvent();
  //m_rawDataEvent->print();
}


//______________________________________________________________________________
int RawDataInputSvc::readRomData(RawDataEvent::RomFee* rom, int& offset, const int& romDataSize)
{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "readRomData(RomFee)" << endreq;

  int romDataRead=0;
  uint32_t temp;

  int channel, channelLast = -1;
  RawDataEvent::PmtChannel pmtChannel;
  while (romDataRead < romDataSize) {
    // data header
    memcpy(&temp, m_buffer + offset, 4);
    offset += 4;
    romDataRead += 4;
    unsigned int dataMarker = get_bits(temp, 29, 3);
    log << MSG::VERBOSE << offset - 4 << ": dataMarker=0x" << hex << dataMarker << dec << endreq;
    switch (dataMarker) {
      case kCBLTHead:
        rom->m_cbltModuleType = get_bits(temp, 16, 4);
        rom->m_cbltGA  = get_bits(temp, 23, 5);
        log << MSG::DEBUG << "GA=" << rom->m_cbltGA << " ModuleType=" << rom->m_cbltModuleType << endreq;
        break;
      case kDataHead:
        rom->m_triggerNum  = get_bits(temp, 0, 8);
        rom->m_status  = get_bits(temp, 8, 8);
        rom->m_triggerType  = get_bits(temp, 16, 4);
        rom->m_version = get_bits(temp, 24, 4);

        // in case of multiple DataHeads
        channelLast = -1;
        if (pmtChannel.filled()) {
          rom->m_channels.push_back(pmtChannel);
          pmtChannel.clear();
        }
        break;
      case kDataCharge:
        channel = get_bits(temp, 25, 4);
        // reset PmtChannel for new channel
        if (channel != channelLast) {
          if (pmtChannel.filled()) {
            rom->m_channels.push_back(pmtChannel);
            pmtChannel.clear();
          }
          channelLast = channel;
          pmtChannel.m_channel = channel;
        }

        pmtChannel.m_adc.push_back(get_bits(temp, 0, 12));
        pmtChannel.m_pedestal.push_back(get_bits(temp, 12, 12));
        pmtChannel.m_adcRange.push_back(get_bits(temp, 24, 1));
        break;
      case kDataTime:
        channel = get_bits(temp, 25, 4);
        if (channel != pmtChannel.m_channel) {
          log << MSG::WARNING << "wrong TDC channel ID: " << channel << " <> PmtChannelId=" << pmtChannel.m_channel << endreq;
        }
        pmtChannel.m_tdc.push_back(get_bits(temp, 0, 17));
        pmtChannel.m_tdcHitCount.push_back(get_bits(temp, 17, 4));
        pmtChannel.m_adcPeakingCycle.push_back(get_bits(temp, 21, 4));
        break;
      case kDataFoot:
        rom->m_dataLength  = get_bits(temp, 0, 10);
        break;
      case kCBLTFoot:
        rom->m_cbltDataLength = get_bits(temp, 0, 18);
        break;
      default:
        log << MSG::WARNING << "unknown DataMarker=0x" << hex << dataMarker << dec << endreq;
        break;
    }
    // stop reading data
    //if (dataMarker == kDataFoot) break;
  } 

  // last PmtChannel
  if (pmtChannel.filled()) {
    rom->m_channels.push_back(pmtChannel);
    pmtChannel.clear();
  }

  return romDataRead;
}


//______________________________________________________________________________
int RawDataInputSvc::readRomData(RawDataEvent::RomFadc* rom, int& offset, const int& romDataSize)
{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "readRomData(RomFadc)" << endreq;

  int romDataRead=0;
  uint32_t temp;

  int channel, channelLast = -1;
  RawDataEvent::FadcChannel fadcChannel;
  while (romDataRead < romDataSize) {
    // data header
    memcpy(&temp, m_buffer + offset, 4);
    offset += 4;
    romDataRead += 4;
    unsigned int dataMarker = get_bits(temp, 29, 3);
    log << MSG::VERBOSE << offset - 4 << ": dataMarker=0x" << hex << dataMarker << dec << endreq;
    switch (dataMarker) {
      case kCBLTHead:
        rom->m_cbltModuleType = get_bits(temp, 16, 4);
        rom->m_cbltGA  = get_bits(temp, 23, 5);
        log << MSG::DEBUG << "GA=" << rom->m_cbltGA << " ModuleType=" << rom->m_cbltModuleType << endreq;
        break;
      case kDataHead:
        rom->m_triggerNum  = get_bits(temp, 0, 8);
        rom->m_status  = get_bits(temp, 8, 8);
        rom->m_triggerType  = get_bits(temp, 16, 4);
        rom->m_version = get_bits(temp, 24, 4);

        // in case of multiple DataHeads
        channelLast = -1;
        if (fadcChannel.filled()) {
          rom->m_channels.push_back(fadcChannel);
          fadcChannel.clear();
        }
        break;
      case kDataCharge:
        channel = get_bits(temp, 24, 4);

        // reset PmtChannel for new channel
        if (channel != channelLast) {
          if (fadcChannel.filled()) {
            rom->m_channels.push_back(fadcChannel);
            fadcChannel.clear();
          }
          channelLast = channel;
          fadcChannel.m_channel = channel;
        }

        fadcChannel.m_adcData.push_back(get_bits(temp, 16, 8));
        fadcChannel.m_adcData.push_back(get_bits(temp, 8, 8));
        fadcChannel.m_adcData.push_back(get_bits(temp, 0, 8));
        break;
      case kDataFoot:
        rom->m_dataLength  = get_bits(temp, 0, 10);
        break;
      case kCBLTFoot:
        rom->m_cbltDataLength = get_bits(temp, 0, 18);
        break;
      default:
        log << MSG::WARNING << "unknown DataMarker=0x" << hex << dataMarker << dec << endreq;
        break;
    }
    // stop reading data
    //if (dataMarker == kDataFoot) break;
  } 

  // last FadcChannel
  if (fadcChannel.filled()) {
    rom->m_channels.push_back(fadcChannel);
    fadcChannel.clear();
  }

  return romDataRead;
}

//______________________________________________________________________________
int RawDataInputSvc::readRomData(RawDataEvent::RomLtb* rom, int& offset, const int& romDataSize)
{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "readRomData(RomLtb)" << endreq;

  uint32_t temp;
  memcpy(&temp, m_buffer + offset + 4*2, 4);
  unsigned int dataformat = get_bits(temp, 25, 3);
  bool utc = dataformat == 7 ? true : false;

  if(utc) {
    return readRomDataUTC(rom,offset,romDataSize);
  } else {
    return readRomDataUnix(rom,offset,romDataSize);
  }

}


//______________________________________________________________________________
int RawDataInputSvc::readRomDataUTC(RawDataEvent::RomLtb* rom,
    int& offset, const int& romDataSize)
{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "readRomData(RomLtb,LtbFrameUTC)" << endreq;

  int romDataRead=0;
  uint32_t temp;

  int nwords=0;
  RawDataEvent::LtbFrameUTC *ltbFrame;

  while (romDataRead < romDataSize) {
    // data header
    memcpy(&temp, m_buffer + offset, 4);
    offset += 4;
    romDataRead += 4;
    unsigned int dataMarker = get_bits(temp, 29, 3);
    switch (dataMarker) {
      case kCBLTHead:
        rom->m_cbltModuleType = get_bits(temp, 16, 4);
        rom->m_cbltGA  = get_bits(temp, 23, 5);
        log << MSG::DEBUG << "GA=" << rom->m_cbltGA << " ModuleType=" << rom->m_cbltModuleType << endreq;
        break;
      case kCBLTFoot:
        rom->m_cbltDataLength = get_bits(temp, 0, 18);
        break;
      case kLtbFrame:
        switch (nwords%7) {
          case 0:
            ltbFrame = new RawDataEvent::LtbFrameUTC();
            rom->m_frames.push_back(ltbFrame);
            ltbFrame->m_triggerSrc      = get_bits(temp, 0, 16);
            ltbFrame->m_rot     = get_bits(temp, 16, 2);
            ltbFrame->m_iltSn   = get_bits(temp, 18, 6);
            ltbFrame->m_clockSystemValid = get_bits(temp, 24, 1) == 1 ? true : false;
            ltbFrame->m_timestampType = get_bits(temp, 25, 1) == 1 ? true : false;
            ltbFrame->m_GPSValid = get_bits(temp, 26, 1) == 1 ? true : false;
            ltbFrame->m_accStat = get_bits(temp, 27, 1) == 1 ? true : false;
            break;
          case 1:
            ltbFrame->m_hour    = get_bits(temp, 0, 6);
            ltbFrame->m_day     = get_bits(temp, 6, 10);
            break;
          case 2:
            ltbFrame->m_second  = get_bits(temp, 0, 7);
            ltbFrame->m_minute  = get_bits(temp, 7, 7);
            ltbFrame->m_nanoSecondLow = get_bits(temp, 16, 4);
            ltbFrame->m_accumulationLow = get_bits(temp, 20, 4);
            break;
          case 3:
            ltbFrame->m_nanoSecondHigh = get_bits(temp, 0, 28);
            break;
          case 4:
            ltbFrame->m_accumulationHigh = get_bits(temp, 0, 28);
            break;
          case 5:
            ltbFrame->m_esumADC = get_bits(temp, 0, 12);
            ltbFrame->m_esumComp        = get_bits(temp, 12, 3);
            ltbFrame->m_hsum    = get_bits(temp, 16, 9);
            break;
          case 6:
            ltbFrame->m_crossTriggerSrc = get_bits(temp, 0, 15);
            ltbFrame->m_blockedValidTrigger = get_bits(temp, 16, 10);
            ltbFrame->m_feeBufferStat = get_bits(temp, 26, 1) == 1 ? true : false;
            break;
        }
        nwords++;
        break;
      case kDataHead:           // ignore
      case kDataFoot:           // ignore
        break;
      default:
        log << MSG::WARNING << hex << "+0x" << romDataRead << ": unknown DataMarker=0x" << dataMarker << dec << endreq;
        break;
    }
  } 

  if (nwords%7 > 0) {
    log << MSG::WARNING << "wrong number of frame words: " << nwords << endreq;
  }

  return romDataRead;
}


//______________________________________________________________________________
int RawDataInputSvc::readRomDataUnix(RawDataEvent::RomLtb* rom,
    int& offset, const int& romDataSize)
{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "readRomData(RomLtb,LtbFrameUnix)" << endreq;

  int romDataRead=0;
  uint32_t temp;

  int nwords=0;
  RawDataEvent::LtbFrameUnix *ltbFrame;

  while (romDataRead < romDataSize) {
    // data header
    memcpy(&temp, m_buffer + offset, 4);
    offset += 4;
    romDataRead += 4;
    unsigned int dataMarker = get_bits(temp, 29, 3);
    switch (dataMarker) {
      case kCBLTHead:
        rom->m_cbltModuleType = get_bits(temp, 16, 4);
        rom->m_cbltGA  = get_bits(temp, 23, 5);
        log << MSG::DEBUG << "GA=" << rom->m_cbltGA << " ModuleType=" << rom->m_cbltModuleType << endreq;
        break;
      case kCBLTFoot:
        rom->m_cbltDataLength = get_bits(temp, 0, 18);
        break;
      case kLtbFrame:
        switch (nwords%7) {
          case 0:
            ltbFrame = new RawDataEvent::LtbFrameUnix();
            rom->m_frames.push_back(ltbFrame);
            ltbFrame->m_triggerSrc      = get_bits(temp, 0, 16);
            ltbFrame->m_rot     = get_bits(temp, 16, 2);
            ltbFrame->m_iltSn   = get_bits(temp, 18, 6);
            ltbFrame->m_clockSystemValid = get_bits(temp, 24, 1) == 1 ? true : false;
            ltbFrame->m_timestampType = get_bits(temp, 25, 1) == 1 ? true : false;
            ltbFrame->m_GPSValid = get_bits(temp, 26, 1) == 1 ? true : false;
            ltbFrame->m_accStat = get_bits(temp, 27, 1) == 1 ? true : false;
            break;
          case 1:
            ltbFrame->m_unixSecHigh = get_bits(temp, 0, 16);
            break;
          case 2:
            ltbFrame->m_unixSecLow= get_bits(temp, 0, 16);
            ltbFrame->m_nanoSecondLow = get_bits(temp, 16, 4);
            ltbFrame->m_accumulationLow = get_bits(temp, 20, 4);
            break;
          case 3:
            ltbFrame->m_nanoSecondHigh = get_bits(temp, 0, 28);
            break;
          case 4:
            ltbFrame->m_accumulationHigh = get_bits(temp, 0, 28);
            break;
          case 5:
            ltbFrame->m_esumADC = get_bits(temp, 0, 12);
            ltbFrame->m_esumComp        = get_bits(temp, 12, 3);
            ltbFrame->m_hsum    = get_bits(temp, 16, 9);
            break;
          case 6:
            ltbFrame->m_crossTriggerSrc = get_bits(temp, 0, 15);
            ltbFrame->m_blockedValidTrigger = get_bits(temp, 16, 10);
            ltbFrame->m_feeBufferStat = get_bits(temp, 26, 1) == 1 ? true : false;
            break;
        }
        nwords++;
        break;
      case kDataHead:           // ignore
      case kDataFoot:           // ignore
        break;
      default:
        log << MSG::WARNING << hex << "+0x" << romDataRead << ": unknown DataMarker=0x" << dataMarker << dec << endreq;
        break;
    }
  } 

  if (nwords%7 > 0) {
    log << MSG::WARNING << "wrong number of frame words: " << nwords << endreq;
  }

  return romDataRead;
}

//______________________________________________________________________________
void RawDataInputSvc::printEvent()
{
  if (!m_isFileHeaderPrinted) {
    m_isFileHeaderPrinted = true;
    m_rawDataEvent->m_fileHeader->print();
  }
  if (m_printFreq>0 && m_rawDataEvent->m_evtNum%m_printFreq == 0) m_rawDataEvent->print();
}

//______________________________________________________________________________
int RawDataInputSvc::queryRawFileFromDB()
{

  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "QueryRawFileFromDatabase!" << endreq;

  // Query Data with Context 
  // TimeStamp tstamp(2009, 8, 26 ,9, 45, 20);
  // Context vc(Site::kDayaBay, SimFlag::kMC, tstamp);
  //DbiResultPtr<DaqRawDataFileInfo>  m_ResPtr(vc, 0,0);

  // Query Data with SeqNo.
  DbiResultPtr<DaqRawDataFileInfo>  m_ResPtr("DaqRawDataFileInfo",m_SeqNo, 0 );
  log << MSG::INFO <<"--------------------------------------------------------"<<std::endl;
  log << MSG::INFO << m_ResPtr.GetValidityRec()-> GetContextRange().AsString() <<std::endl;
  log << MSG::INFO <<" The Num Rows to be queried ==> "<< m_ResPtr.GetNumRows()<< std::endl;

  m_inputFiles.clear();
  for ( UInt_t irow = 0; irow < m_ResPtr.GetNumRows(); ++irow) {
    const  DaqRawDataFileInfo* ddd1 = m_ResPtr.GetRow(irow);
    log << MSG::INFO <<"==> ["<<irow<<"]:"<< "\n"
      <<"RUNNO ="         << ddd1-> GetRunNo()<<"\n  "
      <<"FileNO ="         << ddd1-> GetFileNo()<<"\n  "
      <<"FILENAME="        << ddd1-> GetFileName() <<"\n"
      <<"FILESTATE="       << ddd1-> GetFileState() <<"\n"
      <<"FILESIZE="        << ddd1-> GetFileSize()<<"\n"
      <<"CHECKSUM="        << ddd1-> GetCheckSum()<<"\n"
      <<"TRANSFERSTATE="   << ddd1-> GetTransferState()<<std::endl;
    m_inputFiles.push_back( ddd1->GetFileName() );
  }
  m_SeqNo++;
  return m_inputFiles.size() ;
}

---