In This Package:

RawRecord.cc

Go to the documentation of this file.

#include "RawData/RawRecord.h"
#include "RawData/RawRecordFormat.h"
#include "RawData/RawData.h"
#include <string.h>
#include <sstream>

using namespace DayaBay::RawRecord_v06;

DayaBay::RawRecord::RawRecord(unsigned int* buffer/*=0*/,
                              unsigned int version/*=0*/,
                              bool isOwner/*=false*/)
  : RawBuffer(buffer,isOwner),
    m_version(version)
{
  // Default constructor
}

DayaBay::RawRecord::RawRecord(DayaBay::RawRecord& record,
                              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_version = record.version();
}

DayaBay::RawRecord::~RawRecord()
{
  // Destructor
  m_version=0;
}

unsigned int DayaBay::RawRecord::minimumSize()
{
  // Minimum size for all raw records.
  return RecordFormat::Record::minimumSize;
}

unsigned int DayaBay::RawRecord::type() const
{
  // Return the type of this RawRecord
  return this->getValue(RecordFormat::Record::typeLine);
}

unsigned int DayaBay::RawRecord::size() const
{
  // Return the size of this record, in integer segments
  return this->getValue(RecordFormat::Record::sizeLine);
}

unsigned int DayaBay::RawRecord::version() const
{
  // Version of this record
  return m_version;
}

bool DayaBay::RawRecord::isFileStart() const
{
  // Is this a file start record?
  return (this->type()==RecordFormat::FileStart::type);
}

bool DayaBay::RawRecord::isFileName() const
{
  // Is this a file name record?
  return (this->type()==RecordFormat::FileName::type);
}

bool DayaBay::RawRecord::isMetadata() const
{
  // Is this a metadata record?
  return (this->type()==RecordFormat::Metadata::type);
}

bool DayaBay::RawRecord::isRunParameters() const
{
  // Is this a run parameters record?
  return (this->type()==RecordFormat::RunParameters::type);
}

bool DayaBay::RawRecord::isCalibrationParameters() const
{
  // Is this a calibration parameters record?
  return (this->type()==RecordFormat::CalibrationParameters::type);
}

bool DayaBay::RawRecord::isDataSeparator() const
{
  // Is this a data separator record?
  return (this->type()==RecordFormat::DataSeparator::type);
}

bool DayaBay::RawRecord::isFileEnd() const
{
  // Is this a file end record?
  return (this->type()==RecordFormat::FileEnd::type);
}

DayaBay::RawRecord* DayaBay::RawRecord::clone() const
{
  // Make a full copy of this record
  unsigned int* newBuffer = 0;
  if(this->buffer()){
    unsigned int size = this->size();
    if( this->isDataSeparator() ){ 
      // 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::RawRecord::dump(std::ostream& str){
  // Print the record information
  return str << "Record {type: 0x" << std::hex << this->type() << std::dec 
             << ", "
             << "size: " << this->size() << ", "
             << "version: " << this->version() << "}" << std::endl;
}

DayaBay::RawRecord* DayaBay::RawRecord::makeNewRecord(
                                                     unsigned int* buffer/*=0*/,
                                                     unsigned int version/*=0*/,
                                                     bool isOwner/*=false*/){
  // Make a new record.  Automatically set the correct class type
  // using the type() defined in the raw record.
  // 
  // The caller is responsible for deleting the returned record.
  
  DayaBay::RawRecord* newRecord = 0;
  // Convert to the proper record type
  DayaBay::RawRecord rawRecord(buffer,version);
  if( rawRecord.isFileStart() ){
    newRecord = new DayaBay::RawFileStart(buffer, version, isOwner);
  }else if( rawRecord.isFileName() ){
    newRecord = new DayaBay::RawFileName(buffer, version, isOwner);
  }else if( rawRecord.isMetadata() ){
    newRecord = new DayaBay::RawMetadata(buffer, version, isOwner);
  }else if( rawRecord.isRunParameters() ){
    newRecord = new DayaBay::RawRunParameters(buffer, version, isOwner);
  }else if( rawRecord.isCalibrationParameters() ){
    newRecord = new DayaBay::RawCalibrationParameters(buffer, version, isOwner);
  }else if( rawRecord.isDataSeparator() ){
    newRecord = new DayaBay::RawDataSeparator(buffer, version, isOwner);
  }else if( rawRecord.isFileEnd() ){
    newRecord = new DayaBay::RawFileEnd(buffer, version, isOwner);
  }else{
    newRecord = new DayaBay::RawRecord(buffer, version, isOwner);
  }
  return newRecord;
}


DayaBay::RawFileStart::RawFileStart(unsigned int* buffer/*=0*/,
                                    unsigned int version/*=0*/,
                                    bool isOwner/*=false*/)
  : RawRecord(buffer,version,isOwner)
{
  // Default constructor
}

DayaBay::RawFileStart::RawFileStart(DayaBay::RawRecord& record,
                                    bool adopt/*=false*/)
  : RawRecord(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)
}

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

unsigned int DayaBay::RawFileStart::fileVersion() const
{
  return this->getValue(RecordFormat::FileStart::fileVersionLine);
}

unsigned int DayaBay::RawFileStart::fileNumber() const
{
  return this->getValue(RecordFormat::FileStart::fileNumberLine);
}

unsigned int DayaBay::RawFileStart::date() const
{
  return this->getValue(RecordFormat::FileStart::dateLine);
}

unsigned int DayaBay::RawFileStart::time() const
{
  return this->getValue(RecordFormat::FileStart::timeLine);
}

unsigned int DayaBay::RawFileStart::sizeLimitDataBlocks() const
{
  return this->getValue(RecordFormat::FileStart::sizeLimitDataBlocksLine);
}

unsigned int DayaBay::RawFileStart::sizeLimitMB() const
{
  return this->getValue(RecordFormat::FileStart::sizeLimitMBLine);
}

std::ostream& DayaBay::RawFileStart::dump(std::ostream& str){
  // Print the record information
  str << "RawFileStart {" << std::endl << "  ";
  this->RawRecord::dump(str);
  return str << "  fileVersion: " << this->fileVersion() << std::endl
             << "  fileNumber: " << this->fileNumber() << std::endl
             << "  date: " << this->date() << std::endl
             << "  time: " << this->time() << std::endl
             << "  sizeLimitDataBlocks: " << this->sizeLimitDataBlocks() 
             << std::endl
             << "  sizeLimitMB: " << this->sizeLimitMB() << " }" << std::endl;
}



DayaBay::RawFileName::RawFileName(unsigned int* buffer/*=0*/,
                                  unsigned int version/*=0*/,
                                  bool isOwner/*=false*/)
  : RawRecord(buffer,version,isOwner)
{
  // Default constructor
}

DayaBay::RawFileName::RawFileName(DayaBay::RawRecord& record,
                                  bool adopt/*=false*/)
  : RawRecord(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)
}

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

char* DayaBay::RawFileName::appName() const
{
  return this->getString(RecordFormat::FileName::appNameLine);
}

unsigned int DayaBay::RawFileName::appNameLength() const
{
  return this->getValue(RecordFormat::FileName::appNameLengthLine);
}

char* DayaBay::RawFileName::fileName() const
{
  // Add enough integer lines to account for app name string size
  unsigned int stringLineLength = this->appNameLength()*sizeof(char)
    +sizeof(unsigned int) - 1;
  stringLineLength /= sizeof(unsigned int);
  return this->getString(RecordFormat::FileName::appNameLine
                         +stringLineLength+1);
}

unsigned int DayaBay::RawFileName::fileNameLength() const
{
  // Add enough integer lines to account for app name string size
  unsigned int stringLineLength = this->appNameLength()*sizeof(char)
    +sizeof(unsigned int) - 1;
  stringLineLength /= sizeof(unsigned int);
  return this->getValue(RecordFormat::FileName::appNameLine
                        +stringLineLength);
}

std::ostream& DayaBay::RawFileName::dump(std::ostream& str){
  // Print the record information
  str << "RawFileName {" << std::endl << "  ";
  this->RawRecord::dump(str);
  return str << "  appNameLength: " << this->appNameLength() << std::endl
             << "  appName: " << std::string(this->appName(),
                                             this->appNameLength()) << std::endl
             << "  fileNameLength: " << this->fileNameLength() << std::endl
             << "  fileName: " << std::string(this->fileName(),
                                              this->fileNameLength()) << " }" 
             << std::endl;
}


DayaBay::RawMetadata::RawMetadata(unsigned int* buffer/*=0*/,
                                  unsigned int version/*=0*/,
                                  bool isOwner/*=false*/)
  : RawRecord(buffer,version,isOwner)
{
  // Default constructor
}

DayaBay::RawMetadata::RawMetadata(DayaBay::RawRecord& record,
                                  bool adopt/*=false*/)
  : RawRecord(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)
}

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

unsigned int DayaBay::RawMetadata::entries() const
{
  return this->getValue(RecordFormat::Metadata::entriesLine);
}

char* DayaBay::RawMetadata::string(unsigned int index) const
{
  if(index >= this->entries()) return 0;
  unsigned int currentLine = RecordFormat::Metadata::entriesLine + 1;
  for(unsigned int i = 0; i<index; i++){
    // add offset from each string
    unsigned int stringLength = this->getValue(currentLine)*sizeof(char);
    stringLength += (sizeof(unsigned int) / sizeof(char)) - 1;
    stringLength /= sizeof(unsigned int);
    currentLine += 1 + stringLength;
  }
  return this->getString(currentLine + 1);
}

unsigned int DayaBay::RawMetadata::stringLength(unsigned int index) const
{
  if(index >= this->entries()) return 0;
  unsigned int currentLine = RecordFormat::Metadata::entriesLine + 1;
  for(unsigned int i = 0; i<index; i++){
    // add offset from each string
    unsigned int stringLength = this->getValue(currentLine)*sizeof(char);
    stringLength += (sizeof(unsigned int) / sizeof(char)) - 1;
    stringLength /= sizeof(unsigned int);
    currentLine += 1 + stringLength;
  }
  return this->getValue(currentLine);
}

std::ostream& DayaBay::RawMetadata::dump(std::ostream& str){
  // Print the record information
  str << "Metadata {" << std::endl << "  ";
  this->RawRecord::dump(str);
  str << "  entries: " << this->entries() << std::endl;
  for(unsigned int idx=0; idx < this->entries(); idx++){
    str << "  stringLength: " << this->stringLength(idx) << std::endl
        << "  string: " << std::string(this->string(idx),
                                       this->stringLength(idx)) << std::endl;
  }
  return str << "}" << std::endl;
}



DayaBay::RawRunParameters::RawRunParameters(unsigned int* buffer/*=0*/,
                                            unsigned int version/*=0*/,
                                            bool isOwner/*=false*/)
  : RawRecord(buffer,version,isOwner)
{
  // Default constructor
}

DayaBay::RawRunParameters::RawRunParameters(DayaBay::RawRecord& record,
                                            bool adopt/*=false*/)
  : RawRecord(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)
}

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

unsigned int DayaBay::RawRunParameters::runNumber() const
{
  return this->getValue(RecordFormat::RunParameters::runNumberLine);
}

unsigned int DayaBay::RawRunParameters::reconstructionEnabled() const
{
  return this->getValue(RecordFormat::RunParameters::reconstructionEnabledLine);
}

unsigned int DayaBay::RawRunParameters::triggerType() const
{
  return this->getValue(RecordFormat::RunParameters::triggerTypeLine);
}

unsigned int DayaBay::RawRunParameters::detectorMask() const
{
  return this->getValue(RecordFormat::RunParameters::detectorMaskLine);
}

std::ostream& DayaBay::RawRunParameters::dump(std::ostream& str){
  // Print the record information
  str << "RunParameters {" << std::endl << "  ";
  this->RawRecord::dump(str);
  return str << "  runNumber: " << this->runNumber() << std::endl
             << "  reconstructionEnabled: " << this->reconstructionEnabled() 
             << std::endl
             << "  triggerType: " << this->triggerType() << std::endl
             << "  detectorMask: " << this->detectorMask() << " }" << std::endl;
}



DayaBay::RawCalibrationParameters::RawCalibrationParameters(
                                                     unsigned int* buffer/*=0*/,
                                                     unsigned int version/*=0*/,
                                                     bool isOwner/*=false*/)
  : RawRecord(buffer,version,isOwner)
{
  // Default constructor
}

DayaBay::RawCalibrationParameters::RawCalibrationParameters(
                                                     DayaBay::RawRecord& record,
                                                     bool adopt/*=false*/)
  : RawRecord(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)
}

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

unsigned int DayaBay::RawCalibrationParameters::detectorId() const
{
  return this->getValue(RecordFormat::CalibrationParameters::detectorIdLine);
}

unsigned int DayaBay::RawCalibrationParameters::axis() const
{
  return this->getValue(RecordFormat::CalibrationParameters::axisLine);
}

unsigned int DayaBay::RawCalibrationParameters::sourceId() const
{
  return this->getValue(RecordFormat::CalibrationParameters::sourceIdLine);
}

unsigned int DayaBay::RawCalibrationParameters::zPosition() const
{
  return this->getValue(RecordFormat::CalibrationParameters::zPositionLine);
}

unsigned int DayaBay::RawCalibrationParameters::duration() const
{
  return this->getValue(RecordFormat::CalibrationParameters::durationLine);
}

unsigned int DayaBay::RawCalibrationParameters::ledFrequency() const
{
  return this->getValue(RecordFormat::CalibrationParameters::ledFrequencyLine);
}

unsigned int DayaBay::RawCalibrationParameters::ltbMode() const
{
  return this->getValue(RecordFormat::CalibrationParameters::ltbModeLine);
}

std::ostream& DayaBay::RawCalibrationParameters::dump(std::ostream& str){
  // Print the record information
  str << "CalibrationParameters {" << std::endl << "  ";
  this->RawRecord::dump(str);
  return str << "  detectorId: " << this->detectorId() << std::endl
             << "  axis: " << this->axis() << std::endl
             << "  sourceId: " << this->sourceId() << std::endl
             << "  zPosition: " << this->zPosition() << " mm"<< std::endl
             << "  duration: " << this->duration() << std::endl
             << "  ledFrequency: " << this->ledFrequency() << std::endl
             << "  ltbMode: " << this->ltbMode() << " }" << std::endl;
}


DayaBay::RawDataSeparator::RawDataSeparator(unsigned int* buffer/*=0*/,
                                            unsigned int version/*=0*/,
                                            bool isOwner/*=false*/)
  : RawRecord(buffer,version,isOwner)
{
  // Default constructor
}

DayaBay::RawDataSeparator::RawDataSeparator(DayaBay::RawRecord& record,
                                            bool adopt/*=false*/)
  : RawRecord(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)
}

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

unsigned int DayaBay::RawDataSeparator::blockNumber() const
{
  return this->getValue(RecordFormat::DataSeparator::blockNumberLine);
}

unsigned int DayaBay::RawDataSeparator::blockSize() const
{
  return this->getValue(RecordFormat::DataSeparator::blockSizeLine);
}

DayaBay::RawData* DayaBay::RawDataSeparator::data() const
{
  return DayaBay::RawData::makeNewData(
               this->getPointer(RecordFormat::DataSeparator::dataLine));
}

std::ostream& DayaBay::RawDataSeparator::dump(std::ostream& str){
  // Print the record information
  str << "DataSeparator {" << std::endl << "  ";
  this->RawRecord::dump(str);
  return str << "  blockNumber: " << this->blockNumber() << std::endl
             << "  blockSize: " << this->blockSize() << " }" << std::endl;
}



DayaBay::RawFileEnd::RawFileEnd(unsigned int* buffer/*=0*/,
                                unsigned int version/*=0*/,
                                bool isOwner/*=false*/)
  : RawRecord(buffer,version,isOwner)
{
  // Default constructor
}

DayaBay::RawFileEnd::RawFileEnd(DayaBay::RawRecord& record,
                                bool adopt/*=false*/)
  : RawRecord(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)
}

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

unsigned int DayaBay::RawFileEnd::date() const
{
  return this->getValue(RecordFormat::FileEnd::dateLine);
}

unsigned int DayaBay::RawFileEnd::time() const
{
  return this->getValue(RecordFormat::FileEnd::timeLine);
}

unsigned int DayaBay::RawFileEnd::eventsInFile() const
{
  return this->getValue(RecordFormat::FileEnd::eventsInFileLine);
}

unsigned int DayaBay::RawFileEnd::dataInFile() const
{
  return this->getValue(RecordFormat::FileEnd::dataInFileLine);
}

unsigned int DayaBay::RawFileEnd::eventsInRun() const
{
  return this->getValue(RecordFormat::FileEnd::eventsInRunLine);
}

unsigned int DayaBay::RawFileEnd::dataInRun() const
{
  return this->getValue(RecordFormat::FileEnd::dataInRunLine);
}

unsigned int DayaBay::RawFileEnd::status() const
{
  return this->getValue(RecordFormat::FileEnd::statusLine);
}

unsigned int DayaBay::RawFileEnd::end() const
{
  return this->getValue(RecordFormat::FileEnd::endLine);
}

std::ostream& DayaBay::RawFileEnd::dump(std::ostream& str){
  // Print the record information
  str << "FileEnd {" << std::endl << "  ";
  this->RawRecord::dump(str);
  return str << "  date: " << this->date() << std::endl
             << "  time: " << this->time() << std::endl
             << "  eventsInFile: " << this->eventsInFile() << std::endl
             << "  dataInFile: " << this->dataInFile() << std::endl
             << "  eventsInRun: " << this->eventsInRun() << std::endl
             << "  dataInRun: " << this->dataInRun() << std::endl
             << "  status: " << this->status() << std::endl
             << "  end: " << std::hex << this->end() << std::dec << " }" 
             << std::endl;
}

---