In This Package:

DaqToOStream.cc

Go to the documentation of this file.

/*
 *  DaqToOStream.cc
 *  FileReadoutFormat
 *
 *  Created by Simon Patton on 7/18/10.
 *  Copyright 2010 DayaBay Collaboration. All rights reserved.
 *
 */
#include "FileReadoutFormat/DaqToOStream.h"

#include "EventReadoutFormat/EventHeader.h"
#include "EventReadoutFormat/EventReadout.h"
#include "FileReadoutFormat/CalibrationParametersRecord.h"
#include "FileReadoutFormat/DataSeparatorRecord.h"
#include "FileReadoutFormat/FileBuffer.h"
#include "FileReadoutFormat/FileEndRecord.h"
#include "FileReadoutFormat/FileNameStrings.h"
#include "FileReadoutFormat/FileStartRecord.h"
#include "FileReadoutFormat/FileTraits.h"
#include "FileReadoutFormat/MetadataStrings.h"
#include "FileReadoutFormat/RunParametersRecord.h"

using DybDaq::CalibrationParametersRecord;
using DybDaq::DataSeparatorRecord;
using DybDaq::EventReadout;
using DybDaq::FileEndRecord;
using DybDaq::FileNameStrings;
using DybDaq::DaqToOStream;
using DybDaq::FileStartRecord;
using DybDaq::FileTraits;
using DybDaq::MetadataStrings;
using DybDaq::RunParametersRecord;
using std::string;

static const unsigned int kBytesInMegabyte = 1024U * 1024U;

DaqToOStream::DaqToOStream(const FileTraits& traits) :
    m_traits(&traits),
    m_ostream(0),
    m_buffers(new DaqBuffer::OutputBufferList()),
    m_fileBase(0),
    m_filePayloadLength(0),
    m_payloadLengthTotal(0),
    m_lastRecord(FileTraits::kFileEndRecord),
    m_dataBlockLimit(0),
    m_megabyteLimit(0),
    m_fileCount(0),
    m_sequenceBlockCount(0),
    m_fileBlockCount(0),
    m_blockCountTotal(0) {
}

DaqToOStream::~DaqToOStream() {
    if (0 != m_fileBase) {
        delete m_fileBase;
    }
    if (0 != m_buffers) {
        delete m_buffers;
    }
    if (0 != m_ostream) {
        delete m_ostream;
    }
}

const string& DaqToOStream::getFileBase() const {
    return *m_fileBase;
}

unsigned int DaqToOStream::getFileBlockCount() const {
    return m_fileBlockCount;
}

unsigned int DaqToOStream::getFileCount() const {
    return m_fileCount;
}

unsigned int DaqToOStream::getLastRecord() const {
    return m_lastRecord;
}

bool DaqToOStream::hasFileBase() const {
    return 0 != m_fileBase;
}

bool DaqToOStream::hasOStream() const {
    return 0 != m_ostream;
}

void DaqToOStream::splitStream() {
    if (0 == m_ostream) {
        return;
    }
    closeStream(*m_ostream);
    delete m_ostream;
    m_ostream = openStream();
}

bool DaqToOStream::open(const FileStartRecord& record) {
    if (hasOStream()) {
        return false;
    }
    if (FileTraits::kFileEndRecord != getLastRecord()) {
        return false;
    }
    m_ostream = openStream();
    m_dataBlockLimit = record.dataBlockLimit(),
    m_megabyteLimit = record.megabyteLimit();
    m_filePayloadLength = 0;
    m_fileBlockCount = 0;
    
    saveBuffer(record);
    m_lastRecord = FileTraits::kFileStartRecord;
    return true;
}

const FileStartRecord* DaqToOStream::openElement(const unsigned int fileCount,
                                                const FileTraits::FileDateTime& dateTime,
                                                const unsigned int dataBlockLimit,
                                                const unsigned int megabyteLimit) {
    m_fileCount = fileCount - 1;
    m_dataBlockLimit = dataBlockLimit,
    m_megabyteLimit = megabyteLimit;
    return openNext(dateTime);
}    

const FileStartRecord* DaqToOStream::openNext(const FileTraits::FileDateTime& dateTime) {
    if (hasOStream()) {
        return 0;
    }
    prepareNext();
    FileStartRecord* record = new FileStartRecord(++m_fileCount,
                                                  dateTime,
                                                  m_dataBlockLimit,
                                                  m_megabyteLimit,
                                                  *m_traits);
    if (open(*record)) {
        return record;
    }
    delete record;
    return 0;
}

bool DaqToOStream::openSequence(const std::string& fileBase,
                               const FileStartRecord& record) {
    setFileBase(fileBase);
    m_dataBlockLimit = record.dataBlockLimit(),
    m_megabyteLimit = record.megabyteLimit();
    return open(record);
}    

const FileStartRecord* DaqToOStream::openSequence(const std::string& fileBase,
                                                 const FileTraits::FileDateTime& dateTime,
                                                 const unsigned int dataBlockLimit,
                                                 const unsigned int megabyteLimit) {
    setFileBase(fileBase);
    m_dataBlockLimit = dataBlockLimit,
    m_megabyteLimit = megabyteLimit;
    return openNext(dateTime);
}    

void DaqToOStream::saveBuffer(const FileBuffer& daqBuffer) {
    daqBuffer.gather(*m_buffers);
    DaqBuffer::OutputBufferList::const_iterator buffer;
    for (buffer = m_buffers->begin();
         buffer != m_buffers->end();
         ++buffer) {
        m_ostream->write((*buffer).first, (*buffer).second);
    }
    m_buffers->clear();
}

void DaqToOStream::setFileBase(const std::string& fileBase) {
    if (0 != m_fileBase) {
        delete m_fileBase;
    }
    m_fileBase = new string(fileBase);
}

bool DaqToOStream::saveFileNameStrings(const FileNameStrings& record) {
    if (FileTraits::kFileStartRecord != m_lastRecord) {
        return false;
    }
    saveBuffer(record);
    m_lastRecord = FileTraits::kFileNameStrings;
    return true;
}

const FileNameStrings* DaqToOStream::saveFileNameStrings(const string& application,
                                                        const string& fileBase) {
    string fileBaseToUse;
    if (0 == m_fileBase) {
        fileBaseToUse = fileBase;
    } else {
        fileBaseToUse = *m_fileBase;
    }
    FileNameStrings* record = new FileNameStrings(application,
                                                  fileBaseToUse,
                                                  *m_traits);
    if (saveFileNameStrings(*record)) {
        return record;
    }
    delete record;
    return 0;
}

bool DaqToOStream::saveMetadataStrings(const MetadataStrings& record) {
    if (FileTraits::kFileNameStrings != m_lastRecord) {
        return false;
    }
    saveBuffer(record);
    m_lastRecord = FileTraits::kMetadataStrings;
    return true;
}

const MetadataStrings* DaqToOStream::saveMetadataStrings(const MetadataStrings::MetadataStringPtrList& metadataStrings) {
    MetadataStrings* record = new MetadataStrings(metadataStrings,
                                                  *m_traits);
    if (saveMetadataStrings(*record)) {
        return record;
    }
    delete record;
    return 0;
}

bool DaqToOStream::saveRunParametersRecord(const RunParametersRecord& record) {
    if (FileTraits::kFileNameStrings != m_lastRecord
        && FileTraits::kMetadataStrings != m_lastRecord) {
        return false;
    }
    saveBuffer(record);
    m_lastRecord = FileTraits::kRunParametersRecord;
    return true;
}

const RunParametersRecord* DaqToOStream::saveRunParametersRecord(const unsigned int runNumber,
                                                                const bool recordEnabled,
                                                                const unsigned int triggerType,
                                                                const unsigned int detectorMask) {
    RunParametersRecord* record = new RunParametersRecord(runNumber,
                                                          recordEnabled,
                                                          triggerType,
                                                          detectorMask,
                                                          *m_traits);
    if (saveRunParametersRecord(*record)) {
        return record;
    }
    delete record;
    return 0;
}

bool DaqToOStream::saveCalibrationParametersRecord(const CalibrationParametersRecord& record) {
    if (FileTraits::kRunParametersRecord != m_lastRecord) {
        return false;
    }    
    saveBuffer(record);
    m_lastRecord = FileTraits::kCalibrationParametersRecord;
    return true;
}

const CalibrationParametersRecord* DaqToOStream::saveCalibrationParametersRecord(const unsigned int detector,
                                                                                const unsigned int adNumber,
                                                                                const unsigned int sourceA,
                                                                                const unsigned int zPositionA,
                                                                                const unsigned int sourceB,
                                                                                const unsigned int zPositionB,
                                                                                const unsigned int sourceC,
                                                                                const unsigned int zPositionC,
                                                                                const unsigned int led1,
                                                                                const unsigned int led2,
                                                                                const unsigned int led1Voltage,
                                                                                const unsigned int led2Voltage,
                                                                                const unsigned int duration,
                                                                                const unsigned int ledFrequency,
                                                                                const unsigned int ledPulseSeparation,
                                                                                const unsigned int ltbMode,
                                                                                const unsigned int motorPower,
                                                                                const unsigned int cameraPower,
                                                                                const unsigned int ledFlashing) {
    CalibrationParametersRecord* record = new CalibrationParametersRecord(detector,
                                                                          adNumber,
                                                                          sourceA,
                                                                          zPositionA,
                                                                          sourceB,
                                                                          zPositionB,
                                                                          sourceC,
                                                                          zPositionC,
                                                                          led1,
                                                                          led2,
                                                                          led1Voltage,
                                                                          led2Voltage,
                                                                          duration,
                                                                          ledFrequency,
                                                                          ledPulseSeparation,
                                                                          ltbMode,
                                                                          motorPower,
                                                                          cameraPower,
                                                                          ledFlashing,
                                                                          *m_traits);
    if (saveCalibrationParametersRecord(*record)) {
        return record;
    }
    delete record;
    return 0;
}

bool DaqToOStream::saveDataSeparatorRecord(const DataSeparatorRecord& record) {
    if (FileTraits::FileTraits::kRunParametersRecord != m_lastRecord
        && FileTraits::kCalibrationParametersRecord != m_lastRecord
        && FileTraits::kDataSeparatorRecord != m_lastRecord) {
        return false;
    }
    saveBuffer(record);
    m_lastRecord = FileTraits::kDataSeparatorRecord;
    return true;
}

void DaqToOStream::eventSaved(unsigned int bytesSaved) {
    ++m_fileBlockCount;
    ++m_sequenceBlockCount;
    m_filePayloadLength += bytesSaved;
}

const DataSeparatorRecord* DaqToOStream::saveEvent(const EventReadout& event) {
    const unsigned int bytesSaved = event.header().totalSize() * DaqBuffer::kBytesInInt;
    eventSaved(bytesSaved);
    const DataSeparatorRecord* record = new DataSeparatorRecord(event,
                                                                m_sequenceBlockCount,
                                                                *m_traits);
    if (saveDataSeparatorRecord(*record)) {
        return record;
    }
    m_filePayloadLength -= bytesSaved;
    --m_sequenceBlockCount;
    --m_fileBlockCount;
    delete record;
    return 0;
}

bool DaqToOStream::close(const FileEndRecord& record) {
    if (FileTraits::FileTraits::kRunParametersRecord != m_lastRecord
        && FileTraits::kCalibrationParametersRecord != m_lastRecord
        && FileTraits::kDataSeparatorRecord != m_lastRecord) {
        return false;
    }
    saveBuffer(record);
    if (0 != m_ostream) {
        closeStream(*m_ostream);
        delete m_ostream;
        m_ostream = 0;
    }
    m_lastRecord = FileTraits::kFileEndRecord;
    return true;
}

const FileEndRecord* DaqToOStream::close(const FileTraits::FileDateTime& dateTime) {
    return close(dateTime,
                 m_blockCountTotal,
                 m_payloadLengthTotal,
                 0x01);
}

const FileEndRecord* DaqToOStream::close(const FileTraits::FileDateTime& dateTime,
                                        const unsigned int blockCountBeforeFile,
                                        const unsigned long payloadLengthBeforeFile,
                                        const unsigned int status) {
    unsigned int runBlockCount = blockCountBeforeFile + m_fileBlockCount;
    unsigned long payloadLengthTotal = payloadLengthBeforeFile + m_filePayloadLength;
    const FileEndRecord* record = new FileEndRecord(dateTime,
                                                    m_fileBlockCount,
                                                    (unsigned int)(m_filePayloadLength / kBytesInMegabyte),
                                                    runBlockCount,
                                                    (unsigned int)(payloadLengthTotal / kBytesInMegabyte),
                                                    status,
                                                    *m_traits);
    if (close(*record)) {
        m_blockCountTotal = runBlockCount;
        m_payloadLengthTotal = payloadLengthTotal;
        return record;
    }
    delete record;
    return 0;
}

---