In This Package:

RawData.cc

Go to the documentation of this file.

#include "RawData/RawData.h"
#include "RawData/RawDataFormat.h"
#include <string.h>
#include <sstream>
#include <time.h>

using namespace DayaBay::RawData_v0_6; // Default data format

DayaBay::RawData::RawData(unsigned int* buffer/*=0*/,
                          unsigned int majorVersion/*=0*/,
                          unsigned int minorVersion/*=0*/,
                          bool isOwner/*=false*/)
  : RawBuffer(buffer,isOwner),
    m_majorVersion(majorVersion),
    m_minorVersion(minorVersion)
{
  // Default constructor
}

/*
DayaBay::RawData::RawData(DayaBay::RawData& data,
                          bool adopt=false)
  : RawBuffer(record,adopt)
{
  // Construct from another RawRecord
  // If adopt==true, then take over ownership of the 
  // memory buffer (if the input record is the current owner)
  m_majorVersion = data.majorVersion();
  m_minorVersion = data.minorVersion();
}
*/

DayaBay::RawData::~RawData()
{
  // Destructor
  m_majorVersion=0;
  m_minorVersion=0;
}

unsigned int DayaBay::RawData::type() const
{
  // Return the type of this raw data
  return this->getValue(DataFormat::Data::typeLine);
}

bool DayaBay::RawData::isEventType() const
{
  // Is this event data?
  return (this->type()==DataFormat::Event::type);
}

bool DayaBay::RawData::isModuleType() const
{
  // Is this module data?
  return (this->type()==DataFormat::Module::type);
}

unsigned int DayaBay::RawData::majorVersion() const
{
  // Return the major version of this data
  return m_majorVersion;
}

unsigned int DayaBay::RawData::minorVersion() const
{
  // Return the minor version of this data
  return m_minorVersion;
}

/*
DayaBay::RawData* DayaBay::RawData::clone()
{
  // Make a full copy of this data block
  unsigned int* newBuffer = 0;
  if(this->buffer()){
    unsigned int size = this->size();
    if(this->type() == DayaBay::RawRecord_v0::DataSeparator::type){ 
      // Add additional lines for data block contents
      DayaBay::RawDataSeparator dataSeparator(this->buffer(), this->version());
      size += (dataSeparator.blockSize() + sizeof(unsigned int)-1)
              / sizeof(unsigned int);
    }
    if( size>0 ){
      memcpy( newBuffer, this->buffer(), size*sizeof(unsigned int) );
      if(!newBuffer) return 0;
    }
  }
  return DayaBay::RawRecord::makeNewRecord(newBuffer, m_version, 
                                           true isOwner);
}
*/

std::ostream& DayaBay::RawData::dump(std::ostream& str){
  // Print the data block information
  return str << "Data {type: 0x" << std::hex << this->type() << std::dec 
             << ", "
             << "majorVersion: " << this->majorVersion() << ", "
             << "minorVersion: " << this->minorVersion() << "}" << std::endl;
}

DayaBay::RawData* DayaBay::RawData::makeNewData(unsigned int* buffer/*=0*/,
                                                unsigned int majorVersion/*=0*/,
                                                unsigned int minorVersion/*=0*/,
                                                bool isOwner/*=false*/){
  // Make a new raw data object.  Automatically set the correct class
  // type using the type() defined in the raw data.
  // 
  // The caller is responsible for deleting the returned data object.
  
  DayaBay::RawData* newData = 0;
  // Convert to the proper record type
  DayaBay::RawData rawData(buffer,majorVersion,minorVersion);
  if( rawData.isEventType() ){
    newData = new DayaBay::RawEvent(buffer, majorVersion, minorVersion, 
                                    isOwner);
  }else if( rawData.isModuleType() ){
    newData = new DayaBay::RawModule(buffer, majorVersion, minorVersion, 
                                     isOwner);
  }else{
    newData = new DayaBay::RawData(buffer, majorVersion, minorVersion,
                                   isOwner);
  }
  return newData;
}


DayaBay::RawEvent::RawEvent(unsigned int* buffer/*=0*/,
                            unsigned int majorVersion/*=0*/,
                            unsigned int minorVersion/*=0*/,
                            bool isOwner/*=false*/)
  : RawData(buffer,majorVersion,minorVersion,isOwner),
    m_currentModuleLine(0)
{
  // Default constructor
  if(buffer){
    // Override the version based on the version defined within the data block
    m_majorVersion = this->eventMajorVersion();
    m_minorVersion = this->eventMinorVersion();
  }
}

DayaBay::RawEvent::~RawEvent()
{
  // Destructor
  m_currentModuleLine=0;
}

DayaBay::RawEvent* DayaBay::RawEvent::clone() const
{
  // Make a full copy of this event
  unsigned int* newBuffer = 0;
  if(this->buffer()){
    unsigned int size = this->size();
    if( size>0 ){
      newBuffer = new unsigned int[size];
      memcpy( newBuffer, this->buffer(), size*sizeof(unsigned int) );
      if(!newBuffer) return 0;
    }
  }
  return new DayaBay::RawEvent(newBuffer, 
                               this->majorVersion(), 
                               this->minorVersion(),
                               true /*isOwner*/);
}

unsigned int DayaBay::RawEvent::size() const
{
  return this->getValue(DataFormat::Event::totalSizeLine,
                        DataFormat::Event::totalSizeBitOffset,
                        DataFormat::Event::totalSizeBitLength);
}

unsigned int DayaBay::RawEvent::headerSize() const
{
  return this->getValue(DataFormat::Event::headerSizeLine,
                        DataFormat::Event::headerSizeBitOffset,
                        DataFormat::Event::headerSizeBitLength);
}

unsigned int DayaBay::RawEvent::eventMajorVersion() const
{
  return this->getValue(DataFormat::Event::majorVersionLine,
                        DataFormat::Event::majorVersionBitOffset,
                        DataFormat::Event::majorVersionBitLength);
}

unsigned int DayaBay::RawEvent::eventMinorVersion() const
{
  return this->getValue(DataFormat::Event::minorVersionLine,
                        DataFormat::Event::minorVersionBitOffset,
                        DataFormat::Event::minorVersionBitLength);
}

unsigned int DayaBay::RawEvent::siteId() const
{
  return this->getValue(DataFormat::Event::siteIdLine,
                        DataFormat::Event::siteIdBitOffset,
                        DataFormat::Event::siteIdBitLength);
}

unsigned int DayaBay::RawEvent::detectorId() const
{
  return this->getValue(DataFormat::Event::detectorIdLine,
                        DataFormat::Event::detectorIdBitOffset,
                        DataFormat::Event::detectorIdBitLength);
}

unsigned int DayaBay::RawEvent::runNumber() const
{
  return this->getValue(DataFormat::Event::runNumberLine);
}

unsigned int DayaBay::RawEvent::eventId() const
{
  return this->getValue(DataFormat::Event::eventIdLine);
}


unsigned int DayaBay::RawEvent::eventType() const
{
  return this->getValue(DataFormat::Event::eventTypeLine,
                        DataFormat::Event::eventTypeBitOffset,
                        DataFormat::Event::eventTypeBitLength);
}

unsigned int DayaBay::RawEvent::eventTypeValue() const
{
  return this->getValue(DataFormat::Event::eventTypeValueLine,
                        DataFormat::Event::eventTypeValueBitOffset,
                        DataFormat::Event::eventTypeValueBitLength);
}

unsigned int DayaBay::RawEvent::formatFlag() const
{
  return this->getValue(DataFormat::Event::formatFlagLine,
                        DataFormat::Event::formatFlagBitOffset,
                        DataFormat::Event::formatFlagBitLength);
}

unsigned int DayaBay::RawEvent::statusFlag() const
{
  return this->getValue(DataFormat::Event::statusFlagLine,
                        DataFormat::Event::statusFlagBitOffset,
                        DataFormat::Event::statusFlagBitLength);
}

DayaBay::RawModule* DayaBay::RawEvent::nextModule()
{
  // Return the next Module data block in this event
  // Return 0 if no more modules
  unsigned int nextModuleLine = m_currentModuleLine;
  if(!m_currentModuleLine){
    nextModuleLine = DataFormat::Event::firstModuleLine;
  }else{
    unsigned int moduleSize =
      DayaBay::RawModule(this->getPointer(m_currentModuleLine),
                         this->majorVersion(),
                         this->minorVersion()).size();
    nextModuleLine += moduleSize;
  }
  if(nextModuleLine >= this->size()){
    return 0;
  }
  DayaBay::RawData* nextData = DayaBay::RawData::makeNewData(
                                        this->getPointer(nextModuleLine),
                                        this->majorVersion(),
                                        this->minorVersion());
  DayaBay::RawModule* nextModule = dynamic_cast<DayaBay::RawModule*>(nextData);
  if( !nextModule ){
    delete nextData;
    return 0;
  }
  m_currentModuleLine = nextModuleLine;
  return nextModule;
}

void DayaBay::RawEvent::resetModule()
{
  m_currentModuleLine=0;
}

std::ostream& DayaBay::RawEvent::dump(std::ostream& str){
  // Print the record information
  str << "Event {" << std::endl << "  ";
  this->RawData::dump(str);
  str << "  size: " << this->size() << std::endl
      << "  headerSize: " << this->headerSize() << std::endl
      << "  eventMajorVersion: " << this->eventMajorVersion() 
      << std::endl
      << "  eventMinorVersion: " << this->eventMinorVersion() 
      << std::endl
      << "  siteId: " << this->siteId() << std::endl
      << "  detectorId: " << this->detectorId() << std::endl
      << "  runNumber: " << this->runNumber() << std::endl
      << "  eventId: " << this->eventId() << std::endl
      << "  eventType: " << this->eventType() << std::endl
      << "  eventTypeValue: " << this->eventTypeValue() << std::endl
      << "  formatFlag: 0x" << std::hex << this->formatFlag() 
      << std::dec << std::endl
      << "  statusFlag: 0x" << std::hex << this->statusFlag() << std::dec
      << std::endl;
  DayaBay::RawModule* module = 0;
  unsigned int modLine = m_currentModuleLine;
  this->resetModule();
  while( (module=this->nextModule()) ){
    module->dump(str);
  }
  m_currentModuleLine = modLine; // Restore module line counter
  return str << "}" << std::endl;
}



DayaBay::RawModule::RawModule(unsigned int* buffer/*=0*/,
                              unsigned int majorVersion/*=0*/,
                              unsigned int minorVersion/*=0*/,
                              bool isOwner/*=false*/)
  : RawData(buffer,majorVersion,minorVersion,isOwner),
    m_currentFragmentLine(0)
{
  // Default constructor
}

DayaBay::RawModule::~RawModule()
{
  // Destructor
  m_currentFragmentLine=0;
}

unsigned int DayaBay::RawModule::size() const
{
  return this->getValue(DataFormat::Module::totalSizeLine,
                        DataFormat::Module::totalSizeBitOffset,
                        DataFormat::Module::totalSizeBitLength);
}

unsigned int DayaBay::RawModule::headerSize() const
{
  return this->getValue(DataFormat::Module::headerSizeLine,
                        DataFormat::Module::headerSizeBitOffset,
                        DataFormat::Module::headerSizeBitLength);
}


unsigned int DayaBay::RawModule::siteId() const
{
  return this->getValue(DataFormat::Module::siteIdLine,
                        DataFormat::Module::siteIdBitOffset,
                        DataFormat::Module::siteIdBitLength);
}

unsigned int DayaBay::RawModule::detectorId() const
{
  return this->getValue(DataFormat::Module::detectorIdLine,
                        DataFormat::Module::detectorIdBitOffset,
                        DataFormat::Module::detectorIdBitLength);
}

unsigned int DayaBay::RawModule::moduleType() const
{
  return this->getValue(DataFormat::Module::moduleTypeLine,
                        DataFormat::Module::moduleTypeBitOffset,
                        DataFormat::Module::moduleTypeBitLength);
}

unsigned int DayaBay::RawModule::slot() const
{
  return this->getValue(DataFormat::Module::slotLine,
                        DataFormat::Module::slotBitOffset,
                        DataFormat::Module::slotBitLength);
}

bool DayaBay::RawModule::isLocalTriggerModule() const
{
  // Is this a Local Trigger Board Module block?
  return (this->moduleType()==DataFormat::Module::LocalTrigger);
}

bool DayaBay::RawModule::isPmtFeeModule() const
{
  // Is this a PMT FEE Board Module block?
  return (this->moduleType()==DataFormat::Module::PmtFee);
}

bool DayaBay::RawModule::isFlashAdcModule() const
{
  // Is this a Flash ADC Module block?
  return (this->moduleType()==DataFormat::Module::FlashAdc);
}

bool DayaBay::RawModule::isRpcRomModule() const
{
  // Is this an RPC ROM Module block?
  return (this->moduleType()==DataFormat::Module::RpcRom);
}

bool DayaBay::RawModule::isRpcRtmModule() const
{
  // Is this an RPC RTM Module block?
  return (this->moduleType()==DataFormat::Module::RpcRtm);
}

DayaBay::HeadFragment* DayaBay::RawModule::headFragment()
{
  unsigned int headFragmentLine = DataFormat::Module::firstFragmentLine;
  // Check for CBLT header line
  if( DayaBay::RawFragment(this->getPointer(headFragmentLine),
                           this->majorVersion(),
                           this->minorVersion()).type()
      == DataFormat::CbltHeadFragment::type){
    // Skip CBLT header line
    headFragmentLine += DataFormat::CbltHeadFragment::size;
  }
  DayaBay::RawFragment* rawFragment = 
    this->makeNewFragment(
             this->getPointer(headFragmentLine),
             this->majorVersion(),
             this->minorVersion());
  DayaBay::HeadFragment* headFragment = 
    dynamic_cast<DayaBay::HeadFragment*>(rawFragment);
  if(!headFragment){
    delete rawFragment;
    return 0;
  }
  return headFragment;
}

DayaBay::DataFragment* DayaBay::RawModule::nextDataFragment()
{
  unsigned int nextFragmentLine = m_currentFragmentLine;
  if(!m_currentFragmentLine){
    // Find first data fragment
    nextFragmentLine = DataFormat::Module::firstFragmentLine;
    // Check for CBLT header line
    if( DayaBay::RawFragment(this->getPointer(nextFragmentLine),
                             this->majorVersion(),
                             this->minorVersion()).type()
        == DataFormat::CbltHeadFragment::type){
      // Skip CBLT header line
      nextFragmentLine += DataFormat::CbltHeadFragment::size;
    }
    // Check for header line
    if( DayaBay::RawFragment(this->getPointer(nextFragmentLine),
                             this->majorVersion(),
                             this->minorVersion()).type()
        == DataFormat::HeadFragment::type){
      // Skip header line
      nextFragmentLine += DataFormat::HeadFragment::size;
    }
  }else{
    DayaBay::DataFragment* fragment = 
      this->makeNewDataFragment(this->getPointer(m_currentFragmentLine),
                                this->majorVersion(),
                                this->minorVersion());
    nextFragmentLine += fragment->size();
    delete fragment;
  }
  if(nextFragmentLine >= this->size()){
    return 0;
  }
  DayaBay::DataFragment* nextFragment = 
    this->makeNewDataFragment(this->getPointer(nextFragmentLine),
                              this->majorVersion(),
                              this->minorVersion());
  if( !nextFragment ) return 0;
  m_currentFragmentLine = nextFragmentLine;
  return nextFragment;
}

void DayaBay::RawModule::resetDataFragment()
{
  m_currentFragmentLine=0;
}

std::ostream& DayaBay::RawModule::dump(std::ostream& str){
  // Print the module information
  str << "Module {" << std::endl << "  ";
  this->RawData::dump(str);
  str << "  size: " << this->size() << std::endl
      << "  headerSize: " << this->headerSize() << std::endl
      << "  siteId: " << this->siteId() << std::endl
      << "  detectorId: " << this->detectorId() << std::endl
      << "  moduleType: " << this->moduleType() << std::endl
      << "  slot: " << this->slot() << std::endl << "  ";
  DayaBay::HeadFragment* headFragment = this->headFragment();
  if(headFragment)
    this->headFragment()->dump(str);
  unsigned int fragmentLine = m_currentFragmentLine;
  this->resetDataFragment();
  DayaBay::DataFragment* dataFragment = 0;
  while( (dataFragment=this->nextDataFragment()) ){
    str << std::endl << "  ";
    dataFragment->dump(str);
  }
  m_currentFragmentLine = fragmentLine; // Restore module line counter
  return str << "}" << std::endl;
}

DayaBay::RawFragment* DayaBay::RawModule::makeNewFragment(
                                                unsigned int* buffer/*=0*/,
                                                unsigned int majorVersion/*=0*/,
                                                unsigned int minorVersion/*=0*/,
                                                bool isOwner/*=false*/)
{
  // Make a new raw fragment.  Automatically set the correct class
  // type using the type() defined in the raw data.
  // 
  // The caller is responsible for deleting the returned object.
  
  DayaBay::RawFragment* newFragment = 0;
  // Convert to the proper record type
  switch (DayaBay::RawFragment(buffer,majorVersion,minorVersion).type()){
  case DataFormat::HeadFragment::type:
    newFragment = this->makeNewHeadFragment(buffer, majorVersion, minorVersion, 
                                            isOwner);
    break;
  case DataFormat::DataFragment::type:
  case DataFormat::FeePeakData_v1::chargeLineType:
  case DataFormat::FeePeakData_v1::timeLineType:
    newFragment = this->makeNewDataFragment(buffer,majorVersion,minorVersion, 
                                            isOwner);
    break;
  case DataFormat::TailFragment::type:
    newFragment = this->makeNewTailFragment(buffer, majorVersion, minorVersion, 
                                            isOwner);
    break;
  default:
    newFragment = new DayaBay::RawFragment(buffer, majorVersion, minorVersion, 
                                           isOwner);
    break;
  }
  return newFragment;
}

DayaBay::HeadFragment* DayaBay::RawModule::makeNewHeadFragment(
                                               unsigned int* buffer/*=0*/,
                                               unsigned int majorVersion/*=0*/,
                                               unsigned int minorVersion/*=0*/,
                                               bool isOwner/*=false*/)
{
  // Make a new head fragment.  Automatically set the correct class
  // type using the type() defined in the raw data.
  // 
  // The caller is responsible for deleting the returned object.
  
  DayaBay::HeadFragment* newFragment = 0;
  if( DayaBay::RawFragment(buffer,majorVersion,minorVersion).type() !=
      DataFormat::HeadFragment::type ){
    return 0;
  }
  if( this->isPmtFeeModule() ){
    // Use FEE-specific data head
    newFragment = new DayaBay::FeeHeadFragment(buffer, majorVersion, 
                                               minorVersion, isOwner);
  }else if( this->isLocalTriggerModule() ){
    // Use LTB-specific data head
    newFragment = new DayaBay::LtbHeadFragment(buffer, majorVersion,
                                               minorVersion, isOwner);
  }else{
    // Use generic data head
    newFragment = new DayaBay::HeadFragment(buffer, majorVersion, 
                                            minorVersion, isOwner);
  }
  return newFragment;
}

DayaBay::TailFragment* DayaBay::RawModule::makeNewTailFragment(
                                               unsigned int* buffer/*=0*/,
                                               unsigned int majorVersion/*=0*/,
                                               unsigned int minorVersion/*=0*/,
                                               bool isOwner/*=false*/)
{
  // Make a new tail fragment.  Automatically set the correct class
  // type using the type() defined in the raw data.
  // 
  // The caller is responsible for deleting the returned object.
  
  DayaBay::TailFragment* newFragment = 0;
  if( DayaBay::RawFragment(buffer,majorVersion,minorVersion).type() !=
      DataFormat::TailFragment::type ){
    return 0;
  }
  if( this->isPmtFeeModule() ){
    // Use FEE-specific data tail
    newFragment = new DayaBay::FeeTailFragment(buffer, majorVersion, 
                                               minorVersion, isOwner);
  }else if( this->isLocalTriggerModule() ){
    // Use LTB-specific data tail
    newFragment = new DayaBay::LtbTailFragment(buffer, majorVersion,
                                               minorVersion, isOwner);
  }else{
    // Use generic data tail
    newFragment = new DayaBay::TailFragment(buffer, majorVersion, 
                                            minorVersion, isOwner);
  }
  return newFragment;
}


DayaBay::DataFragment* DayaBay::RawModule::makeNewDataFragment(
                                               unsigned int* buffer/*=0*/,
                                               unsigned int majorVersion/*=0*/,
                                               unsigned int minorVersion/*=0*/,
                                               bool isOwner/*=false*/)
{
  // Make a new data fragment.  Automatically set the correct class
  // type using the type() defined in the raw data.
  // 
  // The caller is responsible for deleting the returned object.
  
  DayaBay::DataFragment* newFragment = 0;
  unsigned int fragmentType = 
    DayaBay::RawFragment(buffer,majorVersion,minorVersion).type();
  if( (fragmentType != DataFormat::DataFragment::type)
      && (fragmentType != DataFormat::FeePeakData_v1::chargeLineType)
      && (fragmentType != DataFormat::FeePeakData_v1::timeLineType) ){
    return 0;
  }
  if( this->isPmtFeeModule() ){
    // FIXME: need to discriminate different data fragment types!
    // Assume ADC/TDC Peak-finding blocks for all PMT data
    DayaBay::HeadFragment* head = this->headFragment();
    DayaBay::FeeHeadFragment* feeHead = 
      dynamic_cast<DayaBay::FeeHeadFragment*>( head );
    if(!feeHead){
      // DEBUG
      std::cout << "ERROR: Failed to find FEE Header" << std::endl;
    }else{
      newFragment = new DayaBay::FeePeakData(buffer, majorVersion, 
                                             minorVersion,
                                             feeHead->feeDataVersion(),
                                             isOwner);
    }
    delete head;
  }else if( this->isLocalTriggerModule() ){
    DayaBay::HeadFragment* head = this->headFragment();
    DayaBay::LtbHeadFragment* ltbHead = 
      dynamic_cast<DayaBay::LtbHeadFragment*>( head );
    if(!ltbHead){
      // DEBUG
      std::cout << "ERROR: Failed to find LTB Header" << std::endl;
    }else{
      newFragment = new DayaBay::LocalTriggerData(buffer, majorVersion, 
                                                  minorVersion, 
                                                  ltbHead->ltbDataVersion(),
                                                  isOwner);
    }
    delete head;
  }else{
    // Use generic data fragment
    newFragment = new DayaBay::DataFragment(buffer, majorVersion, minorVersion,
                                            isOwner);
  }
  return newFragment;
}



DayaBay::RawFragment::RawFragment(unsigned int* buffer/*=0*/,
                                  unsigned int majorVersion/*=0*/,
                                  unsigned int minorVersion/*=0*/,
                                  bool isOwner/*=false*/)
  : RawData(buffer,majorVersion,minorVersion,isOwner)
{
  // Default constructor
}

DayaBay::RawFragment::~RawFragment()
{
  // Destructor
}

unsigned int DayaBay::RawFragment::size() const
{
  return DataFormat::RawFragment::size;
}

unsigned int DayaBay::RawFragment::type() const
{
  return this->getValue(DataFormat::RawFragment::typeLine,
                        DataFormat::RawFragment::typeBitOffset,
                        DataFormat::RawFragment::typeBitLength);
}

std::ostream& DayaBay::RawFragment::dump(std::ostream& str){
  // Print the module information
  str << "RawFragment {" 
      << "  type: " << this->type() << ", "
      << "  size: " << this->size() << std::endl << "  ";
  this->RawData::dump(str);
  return str << "}" << std::endl;
}


DayaBay::HeadFragment::HeadFragment(unsigned int* buffer/*=0*/,
                                    unsigned int majorVersion/*=0*/,
                                    unsigned int minorVersion/*=0*/,
                                    bool isOwner/*=false*/)
  : RawFragment(buffer,majorVersion,minorVersion,isOwner)
{
  // Default constructor
}

DayaBay::HeadFragment::~HeadFragment()
{
  // Destructor
}

unsigned int DayaBay::HeadFragment::size() const
{
  return DataFormat::HeadFragment::size;
}

unsigned int DayaBay::HeadFragment::headType() const
{
  return DataFormat::HeadFragment::headType;
}

unsigned int DayaBay::HeadFragment::status() const
{
  return this->getValue(DataFormat::HeadFragment::statusLine,
                        DataFormat::HeadFragment::statusBitOffset,
                        DataFormat::HeadFragment::statusBitLength);
}

unsigned int DayaBay::HeadFragment::triggerNumber() const
{
  return this->getValue(DataFormat::HeadFragment::triggerNumberLine,
                        DataFormat::HeadFragment::triggerNumberBitOffset,
                        DataFormat::HeadFragment::triggerNumberBitLength);
}

std::ostream& DayaBay::HeadFragment::dump(std::ostream& str){
  // Print the module information
  str << "HeadFragment {" 
      << "  status: " << this->status() << ", "
      << "  triggerNumber: " << this->triggerNumber() << std::endl;
  this->RawFragment::dump(str);
  return str << "}" << std::endl;
}


DayaBay::TailFragment::TailFragment(unsigned int* buffer/*=0*/,
                                    unsigned int majorVersion/*=0*/,
                                    unsigned int minorVersion/*=0*/,
                                    bool isOwner/*=false*/)
  : RawFragment(buffer,majorVersion,minorVersion,isOwner)
{
  // Default constructor
}

DayaBay::TailFragment::~TailFragment()
{
  // Destructor
}

unsigned int DayaBay::TailFragment::size() const
{
  return DataFormat::TailFragment::size;
}

unsigned int DayaBay::TailFragment::tailType() const
{
  return DataFormat::TailFragment::tailType;
}

unsigned int DayaBay::TailFragment::dataSize() const
{
  return this->getValue(DataFormat::TailFragment::dataSizeLine,
                        DataFormat::TailFragment::dataSizeBitOffset,
                        DataFormat::TailFragment::dataSizeBitLength);
}

std::ostream& DayaBay::TailFragment::dump(std::ostream& str){
  // Print the module information
  str << "TailFragment {" 
      << "  dataSize: " << this->dataSize() << std::endl;
  this->RawFragment::dump(str);
  return str << "}" << std::endl;
}


DayaBay::LtbHeadFragment::LtbHeadFragment(unsigned int* buffer/*=0*/,
                                          unsigned int majorVersion/*=0*/,
                                          unsigned int minorVersion/*=0*/,
                                          bool isOwner/*=false*/)
  : HeadFragment(buffer,majorVersion,minorVersion,isOwner)
{
  // Default constructor
}

DayaBay::LtbHeadFragment::~LtbHeadFragment()
{
  // Destructor
}

unsigned int DayaBay::LtbHeadFragment::headType() const
{
  return DataFormat::LtbHeadFragment::headType;
}

unsigned int DayaBay::LtbHeadFragment::clockError() const
{
  return this->getValue(DataFormat::LtbHeadFragment::clockErrorLine,
                        DataFormat::LtbHeadFragment::clockErrorBitOffset,
                        DataFormat::LtbHeadFragment::clockErrorBitLength);
}

unsigned int DayaBay::LtbHeadFragment::ltbDataVersion() const
{
  return this->getValue(DataFormat::LtbHeadFragment::ltbDataVersionLine,
                        DataFormat::LtbHeadFragment::ltbDataVersionBitOffset,
                        DataFormat::LtbHeadFragment::ltbDataVersionBitLength);
}

unsigned int DayaBay::LtbHeadFragment::numberInternalLocalTrigger() const
{
  return this->getValue(DataFormat::LtbHeadFragment::numIltLine,
                        DataFormat::LtbHeadFragment::numIltBitOffset,
                        DataFormat::LtbHeadFragment::numIltBitLength);
}

unsigned int DayaBay::LtbHeadFragment::numberSavedInternalLocalTrigger() const
{
  return this->getValue(DataFormat::LtbHeadFragment::numSavedIltLine,
                        DataFormat::LtbHeadFragment::numSavedIltBitOffset,
                        DataFormat::LtbHeadFragment::numSavedIltBitLength);
}

std::ostream& DayaBay::LtbHeadFragment::dump(std::ostream& str){
  // Print the module information
  str << "LtbHeadFragment {" 
      << "  ltbDataVersion: " 
      << this->ltbDataVersion() << ", "
      << "  clockError: " 
      << this->clockError() << ", "
      << "  numberInternalLocalTrigger: " 
      << this->numberInternalLocalTrigger() << ", "
      << "  numberSavedInternalLocalTrigger: " 
      << this->numberSavedInternalLocalTrigger() << std::endl;
  this->HeadFragment::dump(str);
  return str << "}" << std::endl;
}



DayaBay::LtbTailFragment::LtbTailFragment(unsigned int* buffer/*=0*/,
                                          unsigned int majorVersion/*=0*/,
                                          unsigned int minorVersion/*=0*/,
                                          bool isOwner/*=false*/)
  : TailFragment(buffer,majorVersion,minorVersion,isOwner)
{
  // Default constructor
}

DayaBay::LtbTailFragment::~LtbTailFragment()
{
  // Destructor
}

unsigned int DayaBay::LtbTailFragment::tailType() const
{
  return DataFormat::LtbTailFragment::tailType;
}

std::ostream& DayaBay::LtbTailFragment::dump(std::ostream& str){
  // Print the module information
  str << "LtbTailFragment {" << std::endl; 
  this->TailFragment::dump(str);
  return str << "}" << std::endl;
}



DayaBay::FeeHeadFragment::FeeHeadFragment(unsigned int* buffer/*=0*/,
                                          unsigned int majorVersion/*=0*/,
                                          unsigned int minorVersion/*=0*/,
                                          bool isOwner/*=false*/)
  : HeadFragment(buffer,majorVersion,minorVersion,isOwner)
{
  // Default constructor
}

DayaBay::FeeHeadFragment::~FeeHeadFragment()
{
  // Destructor
}

unsigned int DayaBay::FeeHeadFragment::headType() const
{
  return DataFormat::FeeHeadFragment::headType;
}

unsigned int DayaBay::FeeHeadFragment::feeDataVersion() const
{
  return this->getValue(DataFormat::FeeHeadFragment::feeDataVersionLine,
                        DataFormat::FeeHeadFragment::feeDataVersionBitOffset,
                        DataFormat::FeeHeadFragment::feeDataVersionBitLength);
}

std::ostream& DayaBay::FeeHeadFragment::dump(std::ostream& str){
  // Print the module information
  str << "FeeHeadFragment {"
      << "  feeDataVersion: " 
      << this->feeDataVersion()    
      << std::endl;
  this->HeadFragment::dump(str);
  return str << "}" << std::endl;
}



DayaBay::FeeTailFragment::FeeTailFragment(unsigned int* buffer/*=0*/,
                                          unsigned int majorVersion/*=0*/,
                                          unsigned int minorVersion/*=0*/,
                                          bool isOwner/*=false*/)
  : TailFragment(buffer,majorVersion,minorVersion,isOwner)
{
  // Default constructor
}

DayaBay::FeeTailFragment::~FeeTailFragment()
{
  // Destructor
}

unsigned int DayaBay::FeeTailFragment::tailType() const
{
  return DataFormat::FeeTailFragment::tailType;
}

std::ostream& DayaBay::FeeTailFragment::dump(std::ostream& str){
  // Print the module information
  str << "FeeTailFragment {" << std::endl; 
  this->TailFragment::dump(str);
  return str << "}" << std::endl;
}



DayaBay::DataFragment::DataFragment(unsigned int* buffer/*=0*/,
                                    unsigned int majorVersion/*=0*/,
                                    unsigned int minorVersion/*=0*/,
                                    bool isOwner/*=false*/)
  : RawFragment(buffer,majorVersion,minorVersion,isOwner)
{
  // Default constructor
}

DayaBay::DataFragment::~DataFragment()
{
  // Destructor
}

unsigned int DayaBay::DataFragment::size() const
{
  return DataFormat::DataFragment::size;
}

unsigned int DayaBay::DataFragment::dataType() const
{
  return DataFormat::DataFragment::dataType;
}

bool DayaBay::DataFragment::isLocalTriggerData() const
{
  // Is this a Local Trigger data fragment?
  return (this->dataType()==DataFormat::LocalTriggerData::dataType);
}

bool DayaBay::DataFragment::isFeePeakData() const
{
  // Is this a FEE Peak-finding data fragment?
  return (this->dataType()==DataFormat::FeePeakData::dataType);
}

std::ostream& DayaBay::DataFragment::dump(std::ostream& str){
  // Print the module information
  str << "DataFragment {" 
      << "  dataType: " << this->dataType() << ", "
      << "  contents: 0x" << std::hex << this->getValue(0) << std::dec 
      << std::endl << "  ";
  this->RawFragment::dump(str);
  return str << "}" << std::endl;
}


DayaBay::LocalTriggerData::LocalTriggerData(unsigned int* buffer/*=0*/,
                                            unsigned int majorVersion/*=0*/,
                                            unsigned int minorVersion/*=0*/,
                                            unsigned int ltbDataVersion/*=0*/,
                                            bool isOwner/*=false*/)
  : DataFragment(buffer,majorVersion,minorVersion,isOwner),
    m_ltbDataVersion(ltbDataVersion)
{
  // Default constructor
}

DayaBay::LocalTriggerData::~LocalTriggerData()
{
  // Destructor
}

unsigned int DayaBay::LocalTriggerData::ltbDataVersion() const
{
  return m_ltbDataVersion;
}

unsigned int DayaBay::LocalTriggerData::size() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return DataFormat::LocalTriggerData_v2::size;
  return DataFormat::LocalTriggerData::size;
}

unsigned int DayaBay::LocalTriggerData::dataType() const
{
  return DataFormat::LocalTriggerData::dataType;
}

unsigned int DayaBay::LocalTriggerData::sequenceNumber() const
{
  return this->getValue(DataFormat::LocalTriggerData::sequenceNumberLine,
                        DataFormat::LocalTriggerData::sequenceNumberBitOffset,
                        DataFormat::LocalTriggerData::sequenceNumberBitLength);
}

unsigned int DayaBay::LocalTriggerData::readOutType() const
{
  return this->getValue(DataFormat::LocalTriggerData::readOutTypeLine,
                        DataFormat::LocalTriggerData::readOutTypeBitOffset,
                        DataFormat::LocalTriggerData::readOutTypeBitLength);
}

unsigned int DayaBay::LocalTriggerData::triggerType() const
{
  return this->getValue(DataFormat::LocalTriggerData::triggerTypeLine,
                        DataFormat::LocalTriggerData::triggerTypeBitOffset,
                        DataFormat::LocalTriggerData::triggerTypeBitLength);
}

unsigned int DayaBay::LocalTriggerData::year() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return 0;
  return this->getValue(DataFormat::LocalTriggerData::yearLine,
                        DataFormat::LocalTriggerData::yearBitOffset,
                        DataFormat::LocalTriggerData::yearBitLength);
}

unsigned int DayaBay::LocalTriggerData::month() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return 0;
  return this->getValue(DataFormat::LocalTriggerData::monthLine,
                        DataFormat::LocalTriggerData::monthBitOffset,
                        DataFormat::LocalTriggerData::monthBitLength);
}

unsigned int DayaBay::LocalTriggerData::day() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return 0;
  return this->getValue(DataFormat::LocalTriggerData::dayLine,
                        DataFormat::LocalTriggerData::dayBitOffset,
                        DataFormat::LocalTriggerData::dayBitLength);
}

unsigned int DayaBay::LocalTriggerData::hour() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version ){
    unsigned int bcdHour = 
      this->getValue(DataFormat::LocalTriggerData_v2::hourLine,
                     DataFormat::LocalTriggerData_v2::hourBitOffset,
                     DataFormat::LocalTriggerData_v2::hourBitLength);
    return (bcdHour & 0xf) + (bcdHour>>4 & 0xf)*10;
  }
  return this->getValue(DataFormat::LocalTriggerData::hourLine,
                        DataFormat::LocalTriggerData::hourBitOffset,
                        DataFormat::LocalTriggerData::hourBitLength);
}

unsigned int DayaBay::LocalTriggerData::minute() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version ){
    unsigned int bcdMin = 
      this->getValue(DataFormat::LocalTriggerData_v2::minuteLine,
                     DataFormat::LocalTriggerData_v2::minuteBitOffset,
                     DataFormat::LocalTriggerData_v2::minuteBitLength);
    return (bcdMin & 0xf) + (bcdMin>>4 & 0xf)*10;
  }
  return this->getValue(DataFormat::LocalTriggerData::minuteLine,
                        DataFormat::LocalTriggerData::minuteBitOffset,
                        DataFormat::LocalTriggerData::minuteBitLength);
}

unsigned int DayaBay::LocalTriggerData::second() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version ){
    unsigned int bcdSec = 
      this->getValue(DataFormat::LocalTriggerData_v2::secondLine,
                     DataFormat::LocalTriggerData_v2::secondBitOffset,
                     DataFormat::LocalTriggerData_v2::secondBitLength);
    return (bcdSec & 0xf) + (bcdSec>>4 & 0xf)*10;
  }
  return this->getValue(DataFormat::LocalTriggerData::secondLine,
                        DataFormat::LocalTriggerData::secondBitOffset,
                        DataFormat::LocalTriggerData::secondBitLength);
}

unsigned int DayaBay::LocalTriggerData::clock() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return 0;
  return this->getValue(DataFormat::LocalTriggerData::clockLine,
                        DataFormat::LocalTriggerData::clockBitOffset,
                        DataFormat::LocalTriggerData::clockBitLength);
}

unsigned int DayaBay::LocalTriggerData::hsum() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return this->getValue(DataFormat::LocalTriggerData_v2::hsumLine,
                          DataFormat::LocalTriggerData_v2::hsumBitOffset,
                          DataFormat::LocalTriggerData_v2::hsumBitLength);
  return this->getValue(DataFormat::LocalTriggerData::hsumLine,
                        DataFormat::LocalTriggerData::hsumBitOffset,
                        DataFormat::LocalTriggerData::hsumBitLength);
}

unsigned int DayaBay::LocalTriggerData::esumComp() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return this->getValue(DataFormat::LocalTriggerData_v2::esumCompLine,
                          DataFormat::LocalTriggerData_v2::esumCompBitOffset,
                          DataFormat::LocalTriggerData_v2::esumCompBitLength);
  return this->getValue(DataFormat::LocalTriggerData::esumCompLine,
                        DataFormat::LocalTriggerData::esumCompBitOffset,
                        DataFormat::LocalTriggerData::esumCompBitLength);
}

unsigned int DayaBay::LocalTriggerData::esum() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return this->getValue(DataFormat::LocalTriggerData_v2::esumLine,
                          DataFormat::LocalTriggerData_v2::esumBitOffset,
                          DataFormat::LocalTriggerData_v2::esumBitLength);
  return this->getValue(DataFormat::LocalTriggerData::esumLine,
                        DataFormat::LocalTriggerData::esumBitOffset,
                        DataFormat::LocalTriggerData::esumBitLength);
}

unsigned int DayaBay::LocalTriggerData::crossTriggerSource() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return this->getValue(
                  DataFormat::LocalTriggerData_v2::crossTriggerSourceLine,
                  DataFormat::LocalTriggerData_v2::crossTriggerSourceBitOffset,
                  DataFormat::LocalTriggerData_v2::crossTriggerSourceBitLength);
  return this->getValue(DataFormat::LocalTriggerData::crossTriggerSourceLine,
                    DataFormat::LocalTriggerData::crossTriggerSourceBitOffset,
                    DataFormat::LocalTriggerData::crossTriggerSourceBitLength);
}

// Functions in LTB data v2
unsigned int DayaBay::LocalTriggerData::accumulationStatus() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return this->getValue(
                  DataFormat::LocalTriggerData_v2::accumulationStatusLine,
                  DataFormat::LocalTriggerData_v2::accumulationStatusBitOffset,
                  DataFormat::LocalTriggerData_v2::accumulationStatusBitLength);
  return 0;
}

unsigned int DayaBay::LocalTriggerData::gpsValid() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return this->getValue(DataFormat::LocalTriggerData_v2::gpsValidLine,
                          DataFormat::LocalTriggerData_v2::gpsValidBitOffset,
                          DataFormat::LocalTriggerData_v2::gpsValidBitLength);
  return 0;
}

unsigned int DayaBay::LocalTriggerData::timestampType() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return this->getValue(DataFormat::LocalTriggerData_v2::timestampTypeLine,
                       DataFormat::LocalTriggerData_v2::timestampTypeBitOffset,
                       DataFormat::LocalTriggerData_v2::timestampTypeBitLength);
  return 0;
}

unsigned int DayaBay::LocalTriggerData::clockValid() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return this->getValue(DataFormat::LocalTriggerData_v2::clockValidLine,
                          DataFormat::LocalTriggerData_v2::clockValidBitOffset,
                          DataFormat::LocalTriggerData_v2::clockValidBitLength);
  return 0;
}

unsigned int DayaBay::LocalTriggerData::unixtimeHigh() const
{
  if( this->isUnixTime() )
    return this->getValue(DataFormat::LocalTriggerData_v2::unixtimeHighLine,
                        DataFormat::LocalTriggerData_v2::unixtimeHighBitOffset,
                        DataFormat::LocalTriggerData_v2::unixtimeHighBitLength);
  return 0;
}

unsigned int DayaBay::LocalTriggerData::unixtimeLow() const
{
  if( this->isUnixTime() )
    return this->getValue(DataFormat::LocalTriggerData_v2::unixtimeLowLine,
                         DataFormat::LocalTriggerData_v2::unixtimeLowBitOffset,
                         DataFormat::LocalTriggerData_v2::unixtimeLowBitLength);
  return 0;
}

unsigned int DayaBay::LocalTriggerData::unixtime() const
{
  if( this->isUnixTime() )
    return (this->unixtimeHigh()<<DataFormat::LocalTriggerData_v2::unixtimeLowBitLength | this->unixtimeLow());
  return 0;
}

unsigned int DayaBay::LocalTriggerData::days() const
{
  if( this->isUtcTime() )
    return this->getValue(DataFormat::LocalTriggerData_v2::daysLine,
                          DataFormat::LocalTriggerData_v2::daysBitOffset,
                          DataFormat::LocalTriggerData_v2::daysBitLength);
  return 0;
}

unsigned int DayaBay::LocalTriggerData::accumulationHigh() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return this->getValue(DataFormat::LocalTriggerData_v2::accumulationHighLine,
                    DataFormat::LocalTriggerData_v2::accumulationHighBitOffset,
                    DataFormat::LocalTriggerData_v2::accumulationHighBitLength);
  return 0;
}

unsigned int DayaBay::LocalTriggerData::nanosecondHigh() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return this->getValue(DataFormat::LocalTriggerData_v2::nanosecondHighLine,
                      DataFormat::LocalTriggerData_v2::nanosecondHighBitOffset,
                      DataFormat::LocalTriggerData_v2::nanosecondHighBitLength);
  return 0;
}

unsigned int DayaBay::LocalTriggerData::accumulationLow() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return this->getValue(DataFormat::LocalTriggerData_v2::accumulationLowLine,
                     DataFormat::LocalTriggerData_v2::accumulationLowBitOffset,
                     DataFormat::LocalTriggerData_v2::accumulationLowBitLength);
  return 0;
}

unsigned int DayaBay::LocalTriggerData::nanosecondLow() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return this->getValue(DataFormat::LocalTriggerData_v2::nanosecondLowLine,
                       DataFormat::LocalTriggerData_v2::nanosecondLowBitOffset,
                       DataFormat::LocalTriggerData_v2::nanosecondLowBitLength);
  return 0;
}

int DayaBay::LocalTriggerData::accumulation() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return int(this->accumulationHigh()<<DataFormat::LocalTriggerData_v2::accumulationLowBitLength | this->accumulationLow())/2;
  return 0;
}

unsigned int DayaBay::LocalTriggerData::nanosecond() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return (this->nanosecondHigh()<<DataFormat::LocalTriggerData_v2::nanosecondLowBitLength | this->nanosecondLow())/2;
  return 0;
}

unsigned int DayaBay::LocalTriggerData::feeBufferStatus() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return this->getValue(DataFormat::LocalTriggerData_v2::feeBufferStatusLine,
                     DataFormat::LocalTriggerData_v2::feeBufferStatusBitOffset,
                     DataFormat::LocalTriggerData_v2::feeBufferStatusBitLength);
  return 0;
}

unsigned int DayaBay::LocalTriggerData::ltbBufferStatus() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return this->getValue(DataFormat::LocalTriggerData_v2::ltbBufferStatusLine,
                     DataFormat::LocalTriggerData_v2::ltbBufferStatusBitOffset,
                     DataFormat::LocalTriggerData_v2::ltbBufferStatusBitLength);
  return 0;
}

unsigned int DayaBay::LocalTriggerData::blockedTrigger() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return this->getValue(DataFormat::LocalTriggerData_v2::blockedTriggerLine,
                      DataFormat::LocalTriggerData_v2::blockedTriggerBitOffset,
                      DataFormat::LocalTriggerData_v2::blockedTriggerBitLength);
  return 0;
}

bool DayaBay::LocalTriggerData::isUtcTime() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return (this->timestampType() & this->clockValid() & this->gpsValid());
  return false;
}

bool DayaBay::LocalTriggerData::isUnixTime() const
{
  if( this->ltbDataVersion() >= DataFormat::LocalTriggerData_v2::version )
    return !this->isUtcTime();
  return false;
}

bool DayaBay::LocalTriggerData::isManualTrigger() const
{
  // Is this a Manual Trigger?
  return (this->triggerType() & DataFormat::LocalTriggerData::TriggerType::kManual);
}

bool DayaBay::LocalTriggerData::isCrossTrigger() const
{
  // Is this a Cross Trigger?
  return (this->triggerType() & DataFormat::LocalTriggerData::TriggerType::kCross);
}

bool DayaBay::LocalTriggerData::isPeriodicTrigger() const
{
  // Is this a Periodic Trigger?
  return (this->triggerType() & DataFormat::LocalTriggerData::TriggerType::kPeriodic);
}

bool DayaBay::LocalTriggerData::isMultiplicityTrigger() const
{
  // Is this a Multiplicity Trigger?
  return (this->triggerType() & DataFormat::LocalTriggerData::TriggerType::kMultiplicity);
}

bool DayaBay::LocalTriggerData::isEsumAdcTrigger() const
{
  // Is this an Esum ADC Trigger?
  return (this->triggerType() & DataFormat::LocalTriggerData::TriggerType::kEsumAdc);
}

bool DayaBay::LocalTriggerData::isEsumCompHighTrigger() const
{
  // Is this an Esum Comp High Trigger?
  return (this->triggerType() & DataFormat::LocalTriggerData::TriggerType::kEsumCompHigh);
}

bool DayaBay::LocalTriggerData::isEsumCompLowTrigger() const
{
  // Is this an Esum Comp Low Trigger?
  return (this->triggerType() & DataFormat::LocalTriggerData::TriggerType::kEsumCompLow);
}

bool DayaBay::LocalTriggerData::isEsumCompAllTrigger() const
{
  // Is this an Esum Comp All Trigger?
  return (this->triggerType() & DataFormat::LocalTriggerData::TriggerType::kEsumCompAll);
}

std::ostream& DayaBay::LocalTriggerData::dump(std::ostream& str){
  // Print the module information
  str << "LocalTriggerData {" << std::endl << "  ";
  this->DataFragment::dump(str);
  str << "  sequenceNumber: " << this->sequenceNumber() << ", "
      << "  readOutType: " << this->readOutType() << ", "
      << "  triggerType: " << this->triggerType() << " [ ";
  if(this->isManualTrigger()) str << "Manual, ";
  if(this->isCrossTrigger()) str << "Cross, ";
  if(this->isPeriodicTrigger()) str << "Periodic, ";
  if(this->isMultiplicityTrigger()) str << "Multiplicity, ";
  if(this->isEsumAdcTrigger()) str << "EsumAdc, ";
  if(this->isEsumCompHighTrigger()) str << "EsumCompHigh, ";
  if(this->isEsumCompLowTrigger()) str << "EsumCompLow, ";
  if(this->isEsumCompAllTrigger()) str << "EsumCompAll, ";
  str << " ], ";
  if( this->ltbDataVersion()>=DataFormat::LocalTriggerData_v2::version ){
    str << "  accumulationStatus: " << this->accumulationStatus() << ", "
        << "  gpsValid: " << this->gpsValid() << ", "
        << "  timestampType: " << this->timestampType() << ", "
        << "  clockValid: " << this->clockValid() << ", ";
  }
  if( this->ltbDataVersion() == DataFormat::LocalTriggerData::version ){
    str << "  year: " << this->year() << ", "
        << "  month: " << this->month() << ", "
        << "  day: " << this->day() << ", "
        << "  hour: " << this->hour() << ", "
        << "  minute: " << this->minute() << ", "
        << "  second: " << this->second() << ", "
        << "  clock: " << this->clock() << ", ";
  }else if( this->ltbDataVersion()>=DataFormat::LocalTriggerData_v2::version ){
    if( this->isUtcTime() ){
      str << "  days: " << this->day() << ", "
          << "  hour: " << this->hour() << ", "
          << "  minute: " << this->minute() << ", "
          << "  second: " << this->second() << ", "; 
    }else{
      // Unix time
      time_t unixtime = this->unixtime();
      str << "  unixtimeHigh: " << this->unixtimeHigh() << ", "
          << "  unixtimeLow: " << this->unixtimeLow() << ", "
          << "  unixtime (formatted): " 
          << ctime(&unixtime);
    }
    str << "  nanosecond: " <<  this->nanosecond() << ", "
        << "  accumulation: " <<  this->accumulation() << ", "
        << "  nano+accum: " << this->nanosecond()+this->accumulation() << ", ";
  }

  str << "  hsum: " << this->hsum() << ", "
      << "  esumComp: " << this->esumComp() << ", "
      << "  esum: " << this->esum() << ", ";
  if( this->ltbDataVersion()>=DataFormat::LocalTriggerData_v2::version ){
    str << "  feeBufferStatus: " << this->feeBufferStatus() << ", "
        << "  ltbBufferStatus: " << this->ltbBufferStatus() << ", "
        << "  blockedTrigger: " << this->blockedTrigger() << ", ";
  }
  str << "  crossTriggerSource:  " << this->crossTriggerSource() 
      << std::endl
      << "}" << std::endl;
  return str;
}



DayaBay::FeePeakData::FeePeakData(unsigned int* buffer/*=0*/,
                                  unsigned int majorVersion/*=0*/,
                                  unsigned int minorVersion/*=0*/,
                                  unsigned int feeDataVersion/*=0*/,
                                  bool isOwner/*=false*/)
  : DataFragment(buffer,majorVersion,minorVersion,isOwner),
    m_feeDataVersion(feeDataVersion)
{
  // Default constructor
}

DayaBay::FeePeakData::~FeePeakData()
{
  // Destructor
}

unsigned int DayaBay::FeePeakData::feeDataVersion() const
{
  return m_feeDataVersion;
}

unsigned int DayaBay::FeePeakData::size() const
{
  return DataFormat::FeePeakData::size;
}

unsigned int DayaBay::FeePeakData::dataType() const
{
  return DataFormat::FeePeakData::dataType;
}

unsigned int DayaBay::FeePeakData::channel() const
{
  return this->adcChannel();
}
unsigned int DayaBay::FeePeakData::adcChannel() const
{
  if( this->feeDataVersion() >= DataFormat::FeePeakData_v1::version )
    return this->getValue(DataFormat::FeePeakData_v1::adcChannelLine,
                          DataFormat::FeePeakData_v1::adcChannelBitOffset,
                          DataFormat::FeePeakData_v1::adcChannelBitLength);
  return this->getValue(DataFormat::FeePeakData::adcChannelLine,
                        DataFormat::FeePeakData::adcChannelBitOffset,
                        DataFormat::FeePeakData::adcChannelBitLength);
}

unsigned int DayaBay::FeePeakData::tdcChannel() const
{
  if( this->feeDataVersion() >= DataFormat::FeePeakData_v1::version )
    return this->getValue(DataFormat::FeePeakData_v1::tdcChannelLine,
                          DataFormat::FeePeakData_v1::tdcChannelBitOffset,
                          DataFormat::FeePeakData_v1::tdcChannelBitLength);
  return this->getValue(DataFormat::FeePeakData::tdcChannelLine,
                      DataFormat::FeePeakData::tdcChannelBitOffset,
                      DataFormat::FeePeakData::tdcChannelBitLength);
}

unsigned int DayaBay::FeePeakData::tdc() const
{
  return this->getValue(DataFormat::FeePeakData::tdcLine,
                        DataFormat::FeePeakData::tdcBitOffset,
                        DataFormat::FeePeakData::tdcBitLength);
}

unsigned int DayaBay::FeePeakData::tdcHitCount() const
{
  if( this->feeDataVersion() >= DataFormat::FeePeakData_v1::version )
    return this->getValue(DataFormat::FeePeakData_v1::tdcHitCountLine,
                          DataFormat::FeePeakData_v1::tdcHitCountBitOffset,
                          DataFormat::FeePeakData_v1::tdcHitCountBitLength);
  return this->getValue(DataFormat::FeePeakData::tdcHitCountLine,
                        DataFormat::FeePeakData::tdcHitCountBitOffset,
                        DataFormat::FeePeakData::tdcHitCountBitLength);
}

unsigned int DayaBay::FeePeakData::peakCycle() const
{
  if( this->feeDataVersion() >= DataFormat::FeePeakData_v1::version )
    return this->getValue(DataFormat::FeePeakData_v1::peakCycleLine,
                          DataFormat::FeePeakData_v1::peakCycleBitOffset,
                          DataFormat::FeePeakData_v1::peakCycleBitLength);
  return this->getValue(DataFormat::FeePeakData::peakCycleLine,
                        DataFormat::FeePeakData::peakCycleBitOffset,
                        DataFormat::FeePeakData::peakCycleBitLength);
}

unsigned int DayaBay::FeePeakData::adcRange() const
{
  if( this->feeDataVersion() >= DataFormat::FeePeakData_v1::version )
    return this->getValue(DataFormat::FeePeakData_v1::adcRangeLine,
                          DataFormat::FeePeakData_v1::adcRangeBitOffset,
                          DataFormat::FeePeakData_v1::adcRangeBitLength);
  return this->getValue(DataFormat::FeePeakData::adcRangeLine,
                        DataFormat::FeePeakData::adcRangeBitOffset,
                        DataFormat::FeePeakData::adcRangeBitLength);
}

unsigned int DayaBay::FeePeakData::adc() const
{
  return this->getValue(DataFormat::FeePeakData::adcLine,
                        DataFormat::FeePeakData::adcBitOffset,
                        DataFormat::FeePeakData::adcBitLength);
}

unsigned int DayaBay::FeePeakData::adcPedestal() const
{
  if( this->feeDataVersion() >= DataFormat::FeePeakData_v1::version )
    return this->getValue(DataFormat::FeePeakData_v1::adcPedestalLine,
                          DataFormat::FeePeakData_v1::adcPedestalBitOffset,
                          DataFormat::FeePeakData_v1::adcPedestalBitLength);
  return 0;
}

bool DayaBay::FeePeakData::hasAdcPedestal() const
{
  if( this->feeDataVersion() >= DataFormat::FeePeakData_v1::version )
    return true;
  return false;
};

std::ostream& DayaBay::FeePeakData::dump(std::ostream& str){
  // Print the module information
  str << "FeePeakData {" << std::endl << "  ";
  this->DataFragment::dump(str);
  str << "  channel: " << this->channel() << ", "
      << "  tdc: " << this->tdc() << ", "
      << "  adc: " << this->adc() << ", ";
  if( this->hasAdcPedestal() )
    str << "  adcPedestal: " << this->adcPedestal() << ", ";
  str << "  peakCycle:  " << this->peakCycle() << ", "
      << "  adcRange:  " << this->adcRange() << std::endl
      << "}" << std::endl;
  return str;
}

---