In This Package:

DaqFormatWriter.cc

Go to the documentation of this file.

/*
 *  DaqFormatWriter.cc
 *  DaqFormatModules
 *
 *  Created by Simon Patton on 8/8/10.
 *  Copyright 2010 DayaBay Collaboration. All rights reserved.
 *
 */
#include "DaqFormatModules/DaqFormatWriter.h"

#include <ctime>

#include "DaqReadoutSvc/IDaqReadoutSvc.h"
#include "Event/ReadoutHeader.h"
#include "EventReadoutFormat/EventHeader.h"
#include "EventReadoutFormat/EventReadout.h"
#include "FileReadoutFormat/DataSeparatorRecord.h"
#include "FileReadoutFormat/FileBuffer.h"
#include "FileReadoutFormat/FileEndRecord.h"
#include "FileReadoutFormat/FileNameStrings.h"
#include "FileReadoutFormat/DaqToOStream.h"
#include "FileReadoutFormat/FileStartRecord.h"
#include "FileReadoutFormat/FileTraits.h"
#include "FileReadoutFormat/RunParametersRecord.h"
#include "FileReadoutFormat/MetadataStrings.h"

using DayaBay::ReadoutHeader;
using DybDaq::DataSeparatorRecord;
using DybDaq::DaqFormatWriter;
using DybDaq::EventHeader;
using DybDaq::EventReadout;
using DybDaq::FileBuffer;
using DybDaq::FileEndRecord;
using DybDaq::FileNameStrings;
using DybDaq::DaqToOStream;
using DybDaq::FileStartRecord;
using DybDaq::FileTraits;
using DybDaq::RunParametersRecord;
using DybDaq::MetadataStrings;

static const unsigned int kBytesInInt = 4;
static const unsigned int kBytesInMegabyte = 1024 * 1024;

using namespace DayaBay;

DaqFormatWriter::DaqFormatWriter(const std::string& name,
                                 ISvcLocator* svc) :
DybAlgorithm<DayaBay::ReadoutHeader>(name,
                                     svc),
    m_traits(0),
    m_daqSvc(0),
    m_daqToOStream(0),
    m_fileByteCount(0),
    m_fileByteLimit(0),
    m_fileBlockCount(0),
    m_fileBlockLimit(0) {
    declareProperty("OutputBase",
                    m_outputBase,
                    "The base from which to construct the output file names");
}

DaqFormatWriter::~DaqFormatWriter() {
    if (0 != m_daqToOStream) {
        delete m_daqToOStream;
    }
}

StatusCode DaqFormatWriter::initialize() {
    m_traits = &(FileTraits::defaultTraits());
    StatusCode status = service("DaqReadoutSvc",
                                "DaqReadoutSvc",
                                m_daqSvc);
    if (status.isFailure() ) {
        return status;
    }
    return StatusCode::SUCCESS;
}

StatusCode DaqFormatWriter::execute() {
    const ReadoutHeader* readoutHeader = get<ReadoutHeader>("/Event/Readout/ReadoutHeader");
    if (0 == readoutHeader) {
        error() << "Failed to get readout header." << endreq;
        return StatusCode::FAILURE;
    }
    
    const DaqCrate* daqCrate = readoutHeader->daqCrate();
    if (0 == daqCrate) {
        error() << "Failed to get crate readout from header" << endreq;
        return StatusCode::FAILURE;
    }
    StatusCode status = writeFileHead(daqCrate);
    if (status.isFailure() ) {
      return status;
    }
    return writeData(daqCrate);
}

StatusCode DaqFormatWriter::finalize() {
    const StatusCode status = writeFileFoot();
    if (status.isFailure()) {
        return status;
    }
    return StatusCode::SUCCESS;
}

StatusCode DaqFormatWriter::writeFileHead(const DaqCrate* daqCrate) {
    bool freshFile = false;
    if (0 == m_daqToOStream) {
        if (m_daqSvc->hasFileStartRecord()) {
            const FileStartRecord& record = m_daqSvc->fileStartRecord();
            m_daqToOStream = createDaqToOStream(record.fileTraits());
            if (!(m_daqToOStream->openSequence(m_outputBase,
                                               record))) {
                return StatusCode::FAILURE;
            }
        } else {
            m_daqToOStream = createDaqToOStream(*m_traits);
            const FileTraits::FileDateTime* dateTime = m_traits->makeDateTime(time(0));
            const FileStartRecord* record = m_daqToOStream->openSequence(m_outputBase,
                                                                         *dateTime,
                                                                         m_fileBlockLimit,
                                                                         (m_fileByteLimit / kBytesInMegabyte));
            delete dateTime;
            if (0 == record) {
                return StatusCode::FAILURE;
            }
            delete record;
        }
    } else {
        if (m_daqSvc->hasFileEndRecord()) {
            if (m_daqSvc->hasFileStartRecord()) {
                if (!m_daqToOStream->close(m_daqSvc->fileEndRecord())) {
                    return StatusCode::FAILURE;
                }
                wroteFileFoot();
                if (!m_daqToOStream->open(m_daqSvc->fileStartRecord())) {
                  return StatusCode::FAILURE;
                }
            } else {
                if (!(m_daqToOStream->close(m_daqSvc->fileEndRecord()))) {
                    return StatusCode::FAILURE;
                }
                wroteFileFoot();
                delete m_daqToOStream;
                m_daqToOStream = 0;
                return StatusCode::SUCCESS;
            }
        } else {
            const EventReadout& eventReadout = daqCrate->eventReadout();
            const EventHeader& eventHeader = eventReadout.header();
            ++m_fileBlockCount;
            m_fileByteCount += eventHeader.totalSize() * kBytesInInt;
            if (((0 != m_fileBlockLimit) && (0 == (m_fileBlockCount > m_fileBlockLimit))) ||
                ((0 != m_fileByteLimit) && (0 == (m_fileByteCount > m_fileByteLimit)))) {
                const FileTraits::FileDateTime* dateTime = m_traits->makeDateTime(time(0));
                const FileStartRecord* record = m_daqToOStream->openNext(*dateTime);
                delete dateTime;
                if (0 == record) {
                    return StatusCode::FAILURE;
                }
                delete record;
                m_fileBlockCount = 1;
                m_fileByteCount = eventHeader.totalSize() * kBytesInInt;
                freshFile = true;
            } else {
                return StatusCode::SUCCESS;
            }
        }
    }
    if (m_daqSvc->hasFileNameStrings()) {
        if (!(m_daqToOStream->saveFileNameStrings(m_daqSvc->fileNameStrings()))) {
            return StatusCode::FAILURE;
        }
    } else {
        const FileNameStrings* record = m_daqToOStream->saveFileNameStrings("DaqFormatWriter");
        if (0 == record) {
            return StatusCode::FAILURE;
        }
        delete record;
    }
    if (m_daqSvc->hasMetadataStrings()) {
        if (!(m_daqToOStream->saveMetadataStrings(m_daqSvc->metadataStrings()))) {
            return StatusCode::FAILURE;
        }
    } else {
        MetadataStrings::MetadataStringPtrList* metadataStrings = new MetadataStrings::MetadataStringPtrList();
        MetadataStrings::MetadataString metaString("type","MC");
        metadataStrings->push_back(&metaString);
        const MetadataStrings* record = m_daqToOStream->saveMetadataStrings(*metadataStrings);
        if (0 == record) {
            return StatusCode::FAILURE;
        }
        delete record;
    }
    if (m_daqSvc->hasRunParametersRecord()) {
        if (!(m_daqToOStream->saveRunParametersRecord(m_daqSvc->runParametersRecord()))) {
            return StatusCode::FAILURE;
        }
    } else {
        const RunParametersRecord* record = m_daqToOStream->saveRunParametersRecord(m_daqSvc->runNumber(daqCrate->detector()),
                                                                              true,
                                                                              0,
                                                                              0);
        if (0 == record) {
            return StatusCode::FAILURE;
        }
        delete record;
    }
    if (m_daqSvc->hasCalibrationParametersRecord()) {
        if (!(m_daqToOStream->saveCalibrationParametersRecord(m_daqSvc->calibrationParametersRecord()))) {
            return StatusCode::FAILURE;
        }
    }
    wroteFileHead();
    return StatusCode::SUCCESS;
}

StatusCode DaqFormatWriter::writeData(const DaqCrate* daqCrate) {
    if (0 == m_daqToOStream) {
      return StatusCode::FAILURE;
    }
    const DataSeparatorRecord* record = m_daqToOStream->saveEvent(daqCrate->eventReadout());
    if (0 == record) {
        return StatusCode::FAILURE;
    }
    delete record;
    wroteData();
    return StatusCode::SUCCESS;
}

StatusCode DaqFormatWriter::writeFileFoot() {
    if (0 == m_daqToOStream) {
        return StatusCode::SUCCESS;
    }
    if (m_daqSvc->hasFileEndRecord()) {
        if (!(m_daqToOStream->close(m_daqSvc->fileEndRecord()))) {
            return StatusCode::FAILURE;
        }
    } else {
        const FileTraits::FileDateTime* dateTime = m_traits->makeDateTime(time(0));
        const FileEndRecord* record = m_daqToOStream->close(*dateTime);
        delete dateTime;
        if (0 == record) {
            return StatusCode::FAILURE;
        }
        delete const_cast<FileEndRecord*>(record);
    }
    wroteFileFoot();
    delete m_daqToOStream;
    m_daqToOStream = 0;
    return StatusCode::SUCCESS;
}

---