In This Package:

DaqXmlStream.cc

Go to the documentation of this file.

/*
 *  DaqXmlStream.cc
 *  DaqXml
 *
 *  Created by Simon Patton on 7/22/10.
 *  Copyright 2010 DayaBay Collaboration. All rights reserved.
 *
 */
#include "DaqXml/DaqXmlStream.h"

#include "CbltReadoutFormat/CbltBody.h"
#include "CbltReadoutFormat/CbltFoot.h"
#include "CbltReadoutFormat/CbltHead.h"
#include "CbltReadoutFormat/CbltReadout.h"
#include "CbltReadoutFormat/CbltTraits.h"
#include "FadcReadoutFormat/FadcFoot.h"
#include "FadcReadoutFormat/FadcData.h"
#include "FadcReadoutFormat/FadcHead.h"
#include "FadcReadoutFormat/FadcReadout.h"
#include "FadcReadoutFormat/FadcTraits.h"
#include "FeeReadoutFormat/FeeFoot.h"
#include "FeeReadoutFormat/FeeHead.h"
#include "FeeReadoutFormat/FeeHit.h"
#include "FeeReadoutFormat/FeeReadout.h"
#include "FeeReadoutFormat/FeeTraits.h"
#include "LtbReadoutFormat/LtbFoot.h"
#include "LtbReadoutFormat/LtbFrame.h"
#include "LtbReadoutFormat/LtbHead.h"
#include "LtbReadoutFormat/LtbReadout.h"
#include "LtbReadoutFormat/LtbTraits.h"
#include "EventReadoutFormat/EventReadout.h"
#include "EventReadoutFormat/EventHeader.h"
#include "EventReadoutFormat/EventTraits.h"
#include "DaqReadoutFormat/RomData.h"
#include "EventReadoutFormat/RomFragment.h"
#include "EventReadoutFormat/RomHeader.h"
#include "FileReadoutFormat/CalibrationParametersRecord.h"
#include "FileReadoutFormat/DataSeparatorRecord.h"
#include "FileReadoutFormat/FileEndRecord.h"
#include "FileReadoutFormat/FileNameStrings.h"
#include "FileReadoutFormat/FileBuffer.h"
#include "FileReadoutFormat/FileStartRecord.h"
#include "FileReadoutFormat/FileTraits.h"
#include "FileReadoutFormat/MetadataStrings.h"
#include "FileReadoutFormat/RunParametersRecord.h"

using namespace DybDaq;
using std::endl;
using std::string;

static const string emptyString("");

DaqXmlStream::DaqXmlStream(std::ostream& output,
                           const string& indent,
                           bool strict) :
m_output(&output),
m_indent(new string(indent)),
m_strict(strict) {
}

DaqXmlStream::~DaqXmlStream() {
    if ( 0 != m_indent) {
        delete m_indent;
    }
}

void DaqXmlStream::dumpElement(const FadcData& data) const {
    dumpElement(data,
                emptyString);
}

void DaqXmlStream::dumpElement(const FadcData& data,
                               const string& indent) const {
    string nestedIndent = indent + (*m_indent);
    (*m_output) << indent << "<fadc_data>" << endl;
    (*m_output) << nestedIndent << "<channel>" << data.channelId() << "</channel>" << endl;
    (*m_output) << nestedIndent << "<high_byte>" << ((unsigned int)data.highDataByte()) << "</high_byte>" << endl;
    (*m_output) << nestedIndent << "<middle_byte>" << ((unsigned int)data.middleDataByte()) << "</middle_byte>" << endl;
    (*m_output) << nestedIndent << "<low_byte>" << ((unsigned int)data.lowDataByte()) << "</low_byte>" << endl;
    (*m_output) << indent << "</fadc_data>" << endl;
}

void DaqXmlStream::dumpElement(const FadcFoot& foot) const {
    dumpElement(foot,
                emptyString);
}

void DaqXmlStream::dumpElement(const FadcFoot& foot,
                               const string& indent) const {
    string nestedIndent = indent + (*m_indent);
    (*m_output) << indent << "<fadc_foot";
    if (m_strict) {
        (*m_output) << " length=\"" << foot.dataLength() << "\"";
    }
    (*m_output) << ">" << endl;
    (*m_output) << nestedIndent << "<trigger_number>" << foot.triggerNumber() << "</trigger_number>" << endl;
    (*m_output) << indent << "</fadc_foot>" << endl;
}

void DaqXmlStream::dumpElement(const FadcHead& head) const {
    dumpElement(head,
                emptyString);
}

void DaqXmlStream::dumpElement(const FadcHead& head,
                               const string& indent) const {
    const FadcTraits& traits = head.fadcTraits();
    string nestedIndent = indent + (*m_indent);
    (*m_output) << indent << "<fadc_head format=\"" << head.version() << "\">" << endl;
    (*m_output) << nestedIndent << "<trigger_type>" << traits.triggerTypeAsString(head.triggerType()) << "</trigger_type>" << endl;
    (*m_output) << nestedIndent << "<no_data>" << traits.boolAsString(head.noData()) << "</no_data>" << endl;
    (*m_output) << nestedIndent << "<trigger_number>" << head.triggerNumber() << "</trigger_number>" << endl;
    (*m_output) << indent << "</fadc_head>" << endl;
}

void DaqXmlStream::dumpElement(const FadcReadout& readout) const {
    dumpElement(readout,
                emptyString);
}

void DaqXmlStream::dumpElement(const FadcReadout& readout,
                               const string& indent) const {
    dumpElement(readout.head(),
                indent);
    const FadcReadout::FadcDataPtrList& data = readout.fadcData();
    FadcReadout::FadcDataPtrList::const_iterator entry;
    for (entry = data.begin() ;
         entry != data.end() ;
         ++entry) {
        dumpElement(**entry,
                    indent);
    }
    dumpElement(readout.foot(),
                indent);
}

void DaqXmlStream::dumpElement(const FeeHit& hit) const {
    dumpElement(hit,
                emptyString);
}

void DaqXmlStream::dumpElement(const FeeHit& hit,
                               const string& indent) const {
    string nestedIndent = indent + (*m_indent);
    string doubleIndent = nestedIndent + (*m_indent);
    (*m_output) << indent << "<fee_hit>" << endl;
    (*m_output) << nestedIndent << "<fee_charge>" << endl;
    (*m_output) << doubleIndent << "<channel>" << hit.adcChannelId() << "</channel>" << endl;
    (*m_output) << doubleIndent << "<peak>" << hit.peakCycle() << "</peak>" << endl;
    const char* range;
    if (hit.isHighRangeAdc()) {
        range = "high";
    } else {
        range = "low";
    }
    (*m_output) << doubleIndent << "<range>" << range << "</range>" << endl;
    (*m_output) << doubleIndent << "<value>" << hit.adc() << "</value>" << endl;
    (*m_output) << nestedIndent << "</fee_charge>" << endl;
    (*m_output) << nestedIndent << "<fee_time>" << endl;
    (*m_output) << doubleIndent << "<channel>" << hit.tdcChannelId() << "</channel>" << endl;
    (*m_output) << doubleIndent << "<hit_number>" << hit.hitNumber() << "</hit_number>" << endl;
    (*m_output) << doubleIndent << "<value>" << hit.tdc() << "</value>" << endl;
    (*m_output) << nestedIndent << "</fee_time>" << endl;
    (*m_output) << indent << "</fee_hit>" << endl;
}

void DaqXmlStream::dumpElement(const FeeFoot& foot) const {
    dumpElement(foot,
                emptyString);
}

void DaqXmlStream::dumpElement(const FeeFoot& foot,
                               const string& indent) const {
    string nestedIndent = indent + (*m_indent);
    (*m_output) << indent << "<fee_foot";
    if (m_strict) {
        (*m_output) << " length=\"" << foot.dataLength() << "\"";
    }
    (*m_output) << ">" << endl;
    (*m_output) << nestedIndent << "<trigger_number>" << foot.triggerNumber() << "</trigger_number>" << endl;
    (*m_output) << indent << "</fee_foot>" << endl;
}

void DaqXmlStream::dumpElement(const FeeHead& head) const {
    dumpElement(head,
                emptyString);
}

void DaqXmlStream::dumpElement(const FeeHead& head,
                               const string& indent) const {
    const FeeTraits& traits = head.feeTraits();
    string nestedIndent = indent + (*m_indent);
    (*m_output) << indent << "<fee_head format=\"" << head.version() << "\">" << endl;
    (*m_output) << nestedIndent << "<trigger_type>" << traits.triggerTypeAsString(head.triggerType()) << "</trigger_type>" << endl;
    (*m_output) << nestedIndent << "<checked>" << traits.boolAsString(head.checked()) << "</checked>" << endl;
    (*m_output) << nestedIndent << "<error>" << traits.boolAsString(head.error()) << "</error>" << endl;
    (*m_output) << nestedIndent << "<trigger_number>" << head.triggerNumber() << "</trigger_number>" << endl;
    (*m_output) << indent << "</fee_head>" << endl;
}

void DaqXmlStream::dumpElement(const FeeReadout& readout) const {
    dumpElement(readout,
                emptyString);
}

void DaqXmlStream::dumpElement(const FeeReadout& readout,
                               const string& indent) const {
    dumpElement(readout.head(),
                indent);
    const FeeReadout::FeeHitPtrList& hits = readout.feeHits();
    FeeReadout::FeeHitPtrList::const_iterator hit;
    for (hit = hits.begin() ; hit != hits.end() ; ++hit) {
        dumpElement(**hit,
                    indent);
    }
    dumpElement(readout.foot(),
                indent);
}

void DaqXmlStream::dumpElement(const LtbFrame& frame) const {
    dumpElement(frame,
                emptyString);
}

void DaqXmlStream::dumpElement(const LtbFrame& frame,
                               const string& indent) const {
    const LtbTraits& traits = frame.ltbTraits();
    string nestedIndent = indent + (*m_indent);
    string doubleIndent = nestedIndent + (*m_indent);
    (*m_output) << indent << "<ltb_frame>" << endl;
    const LtbTraits::TriggerLines* lines = traits.triggerLines(frame.triggerMask());
    if (lines->empty()) {
        (*m_output) << nestedIndent << "<trigger_mask/>" << endl;
    } else {
        (*m_output) << nestedIndent << "<trigger_mask>" << endl;
        LtbTraits::TriggerLines::const_iterator line;
        for (line = lines->begin() ; line != lines->end() ; ++line) {
            (*m_output) << doubleIndent  << "<" << *line << "/>" << endl;
        }
        (*m_output) << nestedIndent << "</trigger_mask>" << endl;
    }
    delete lines;
    (*m_output) << nestedIndent << "<time>" << traits.dateTimeAsString(frame.dateTime()) << "</time>" << endl;
    (*m_output) << nestedIndent << "<ticks>" << frame.ticks() << "</ticks>" << endl;
    (*m_output) << nestedIndent << "<hit_sum>" << frame.hitSum() << "</hit_sum>" << endl;
    if (frame.totalEsum() || frame.totalEsum() || frame.totalEsum()) {
        (*m_output) << nestedIndent << "<energy_comparators>" << endl;
        if (frame.totalEsum()) {
            (*m_output) << doubleIndent << "<Total_ESUM_comp/>" << endl;
        }
        if (frame.highEsum()) {
            (*m_output) << doubleIndent << "<High_ESUM_comp/>" << endl;
        }
        if (frame.lowEsum()) {
            (*m_output) << doubleIndent << "<Low_ESUM_comp/>" << endl;
        }
        (*m_output) << nestedIndent << "</energy_comparators>" << endl;
    } else {
        (*m_output) << nestedIndent << "<energy_comparators/>" << endl;
    }
    (*m_output) << nestedIndent << "<energy_sum>" << frame.energySum() << "</energy_sum>" << endl;
    (*m_output) << nestedIndent << "<cross_trigger_source>" << frame.crossTriggerSource() << "</cross_trigger_source>" << endl;
    (*m_output) << nestedIndent << "<frame_number>" << frame.frameNumber() << "</frame_number>" << endl;
    (*m_output) << nestedIndent << "<blocked_trigger_count>" << frame.blockedTriggerCount() << "</blocked_trigger_count>" << endl;
    (*m_output) << indent << "</ltb_frame>" << endl;
}

void DaqXmlStream::dumpElement(const LtbFoot& foot) const {
    dumpElement(foot,
                emptyString);
}

void DaqXmlStream::dumpElement(const LtbFoot& foot,
                               const string& indent) const {
    string nestedIndent = indent + (*m_indent);
    (*m_output) << indent << "<ltb_foot";
    if (m_strict) {
        (*m_output) << " length=\"" << foot.dataLength() << "\"";
    }
    (*m_output) << "/>" << endl;
}

void DaqXmlStream::dumpElement(const LtbHead& head) const {
    dumpElement(head,
                emptyString);
}

void DaqXmlStream::dumpElement(const LtbHead& head,
                               const string& indent) const {
    string nestedIndent = indent + (*m_indent);
    (*m_output) << indent << "<ltb_head";
    if (m_strict) {
        (*m_output) << " frame_count=\"" << head.rawTriggersSaved() << "\"";
    }
    (*m_output) << " format=\"" << head.version() << "\">" << endl;
    (*m_output) << nestedIndent << "<trigger_number>" << head.localTriggerNumber() << "</trigger_number>" << endl;
    (*m_output) << nestedIndent << "<internal_trigger_count>" << head.rawTriggerTotal() << "</internal_trigger_count>" << endl;
    (*m_output) << nestedIndent << "<status>" << head.ltbStatus() << "</status>" << endl;
    (*m_output) << indent << "</ltb_head>" << endl;
}

void DaqXmlStream::dumpElement(const LtbReadout& readout) const {
    dumpElement(readout,
                emptyString);
}

void DaqXmlStream::dumpElement(const LtbReadout& readout,
                               const string& indent) const {
    dumpElement(readout.head(),
                indent);
    const LtbReadout::LtbFramePtrList& frames = readout.ltbFrames();
    LtbReadout::LtbFramePtrList::const_iterator frame;
    for (frame = frames.begin() ; frame != frames.end() ; ++frame) {
        dumpElement(**frame,
                    indent);
    }
    dumpElement(readout.foot(),
                indent);
}

void DaqXmlStream::dumpElement(const CbltBody& body) const {
    dumpElement(body,
                emptyString);
}

void DaqXmlStream::dumpElement(const CbltBody& body,
                               const string& indent) const {
    string nestedIndent = indent + (*m_indent);
    (*m_output) << indent << "<cblt_body>" << endl;
    const RomData& romData = body.data();
    const FadcReadout* fadcReadout;
    const FeeReadout* feeReadout;
    const LtbReadout* ltbReadout;
    if (0 != (fadcReadout = dynamic_cast<const FadcReadout*>(&romData))) {
        dumpElement(*fadcReadout,
                    nestedIndent);
    } else if (0 != (feeReadout = dynamic_cast<const FeeReadout*>(&romData))) {
        dumpElement(*feeReadout,
                    nestedIndent);
    } else if (0 != (ltbReadout = dynamic_cast<const LtbReadout*>(&romData))) {
        dumpElement(*ltbReadout,
                    nestedIndent);
    } else {
        (*m_output) << nestedIndent << "<undefined/>" << endl;
    }
    (*m_output) << indent << "</cblt_body>" << endl;
}

void DaqXmlStream::dumpElement(const CbltFoot& foot) const {
    dumpElement(foot,
                emptyString);
}

void DaqXmlStream::dumpElement(const CbltFoot& foot,
                               const string& indent) const {
    string nestedIndent = indent + (*m_indent);
    (*m_output) << indent << "<cblt_foot";
    if (m_strict) {
        (*m_output) << " length=\"" << foot.dataLength() << "\"";
    }
    (*m_output) << ">" << endl;
    (*m_output) << nestedIndent << "<module_address>" << foot.moduleAddress() << "</module_address>" << endl;
    (*m_output) << indent << "</cblt_foot>" << endl;
}

void DaqXmlStream::dumpElement(const CbltHead& head) const {
    dumpElement(head,
                emptyString);
}

void DaqXmlStream::dumpElement(const CbltHead& head,
                               const string& indent) const {
    const CbltTraits& traits = head.cbltTraits();
    string nestedIndent = indent + (*m_indent);
    (*m_output) << indent << "<cblt_head>" << endl;
    (*m_output) << nestedIndent << "<module_type>" << traits.moduleTypeAsString(head.moduleType()) << "</module_type>" << endl;
    (*m_output) << nestedIndent << "<module_address>" << head.moduleAddress() << "</module_address>" << endl;
    (*m_output) << indent << "</cblt_head>" << endl;
}

void DaqXmlStream::dumpElement(const CbltReadout& readout) const {
    dumpElement(readout,
                emptyString);
}

void DaqXmlStream::dumpElement(const CbltReadout& readout,
                               const string& indent) const {
    dumpElement(readout.head(),
                indent);
    dumpElement(readout.body(),
                indent);
    dumpElement(readout.foot(),
                indent);
}

void DaqXmlStream::dumpElement(const RomHeader& header) const {
    dumpElement(header,
                emptyString);
}

void DaqXmlStream::dumpElement(const RomHeader& header,
                               const string& indent) const {
    const EventTraits& traits = header.eventTraits();
    string nestedIndent = indent + (*m_indent);
    (*m_output) << indent << "<rom_header";
    if (m_strict) {
        (*m_output) << " total_size=\"" << header.totalSize();
        (*m_output) << "\" header_size=\"" << header.headerSize() << "\"";
    }
    (*m_output) << ">" << endl;
    (*m_output) << nestedIndent << "<site>" << traits.siteAsString(header.site()) << "</site>" << endl;
    (*m_output) << nestedIndent << "<detector>" << traits.detectorAsString(header.detector()) << "</detector>" << endl;
    (*m_output) << nestedIndent << "<module_type>" << traits.moduleTypeAsString(header.moduleType()) << "</module_type>" << endl;
    (*m_output) << nestedIndent << "<slot>" << header.slot() << "</slot>" << endl;
    (*m_output) << indent << "</rom_header>" << endl;
}

void DaqXmlStream::dumpElement(const RomFragment& fragment) const {
    dumpElement(fragment,
                emptyString);
}

void DaqXmlStream::dumpElement(const RomFragment& fragment,
                               const string& indent) const {
    string nestedIndent = indent + (*m_indent);
    string doubleIndent = nestedIndent + (*m_indent);
    (*m_output) << indent << "<rom_fragment>" << endl;
    dumpElement(fragment.header(),
                nestedIndent);
    
    (*m_output) << nestedIndent << "<rom_data>" << endl;
    const RomData& romData = fragment.data();
    const CbltReadout* cbltReadout;
    const FadcReadout* fadcReadout;
    const FeeReadout* feeReadout;
    const LtbReadout* ltbReadout;
    if (0 != (cbltReadout = dynamic_cast<const CbltReadout*>(&romData))) {
        dumpElement(*cbltReadout,
                    doubleIndent);
    } else if (0 != (fadcReadout = dynamic_cast<const FadcReadout*>(&romData))) {
        dumpElement(*fadcReadout,
                    doubleIndent);
    } else if (0 != (feeReadout = dynamic_cast<const FeeReadout*>(&romData))) {
        dumpElement(*feeReadout,
                    doubleIndent);
    } else if (0 != (ltbReadout = dynamic_cast<const LtbReadout*>(&romData))) {
        dumpElement(*ltbReadout,
                    doubleIndent);
    } else {
        (*m_output) << doubleIndent << "<undefined/>" << endl;
    }
    (*m_output) << nestedIndent << "</rom_data>" << endl;
    (*m_output) << indent << "</rom_fragment>" << endl;
}

void DaqXmlStream::dumpElement(const EventHeader& header) const {
    dumpElement(header,
                emptyString);
}

void DaqXmlStream::dumpElement(const EventHeader& header,
                               const string& indent) const {
    const EventTraits& traits = header.eventTraits();
    string nestedIndent = indent + (*m_indent);
    (*m_output) << indent << "<event_header";
    if (m_strict) {
        (*m_output) << " total_size=\"" << header.totalSize();
        (*m_output) << "\" header_size=\"" << header.headerSize() << "\"";
    }
    (*m_output) << " format=\"" << header.majorVersion() << "." << header.minorVersion() << "\">" << endl;
    (*m_output) <<  nestedIndent << "<site>" << traits.siteAsString(header.site()) << "</site>" << endl;
    (*m_output) <<  nestedIndent << "<detector>" << traits.detectorAsString(header.detector()) << "</detector>" << endl;
    (*m_output) <<  nestedIndent << "<run>" << header.run() << "</run>" << endl;
    (*m_output) <<  nestedIndent << "<event>" << header.event() << "</event>" << endl;
    (*m_output) <<  nestedIndent << "<data_type>" << traits.dataTypeAsString(header.dataType()) << "</data_type>" << endl;
    if (header.cbltWrapping() || m_strict) {
        (*m_output) <<  nestedIndent << "<cblt_wrapping>" << traits.boolAsString(header.cbltWrapping()) << "</cblt_wrapping>" << endl;
    }
    if (header.rawCblt() || m_strict) {
        (*m_output) <<  nestedIndent << "<raw_cblt>" << traits.boolAsString(header.rawCblt()) << "</raw_cblt>" << endl;
    }
    if (header.triggerMismatch() || m_strict) {
        (*m_output) <<  nestedIndent << "<trigger_mismatch>" << traits.boolAsString(header.triggerMismatch()) << "</trigger_mismatch>" << endl;
    }
    if (header.invalidData() || m_strict) {
        (*m_output) <<  nestedIndent << "<invalid_data>" << traits.boolAsString(header.invalidData()) << "</invalid_data>" << endl;
    }
    (*m_output) <<  indent << "</event_header>" << endl;
}

void DaqXmlStream::dumpElement(const EventReadout& readout) const {
    dumpElement(readout,
                emptyString);
}

void DaqXmlStream::dumpElement(const EventReadout& readout,
                               const string& indent) const {
    string nestedIndent = indent + (*m_indent);
    (*m_output) << indent << "<event>" << endl;
    dumpElement(readout.header(),
                nestedIndent);
    const EventReadout::RomFragmentPtrList& fragments = readout.romFragments();
    for (EventReadout::RomFragmentPtrList::const_iterator fragment = fragments.begin();
             fragment != fragments.end();
             ++fragment) {
        dumpElement(*(*fragment),
                    nestedIndent);
    }
    (*m_output) << indent << "</event>" << endl;
}

void DaqXmlStream::dumpElement(const FileEndRecord& record) const {
    dumpElement(record,
                emptyString);
}

void DaqXmlStream::dumpElement(const FileEndRecord& record,
                               const string& indent) const {
    const FileTraits& traits = record.fileTraits();
    string nestedIndent = indent + (*m_indent);
    (*m_output) << indent << "<file_end_record";
    if (m_strict) {
        const char* last;
        if (record.endMarkerFound()) {
            last = "true";
        } else {
            last = "false";
        }
        (*m_output) << " last=\"" << last << "\" size=\"" << record.size() << "\"";
    }
    (*m_output) << ">" << endl;
    (*m_output) << nestedIndent << "<time>" << traits.dateTimeAsString(record.dateTime()) << "</time>" << endl;
    (*m_output) << nestedIndent << "<file_event_count>" << record.fileEventCount() << "</file_event_count>" << endl;
    (*m_output) << nestedIndent << "<file_payload_size>" << record.filePayloadSize() << "</file_payload_size>" << endl;
    (*m_output) << nestedIndent << "<run_event_count>" << record.runEventCount() << "</run_event_count>" << endl;
    (*m_output) << nestedIndent << "<run_payload_size>" << record.runPayloadSize() << "</run_payload__size>" << endl;
    (*m_output) << nestedIndent << "<status>" << record.status() << "</status>" << endl;
    (*m_output) << indent << "</file_end_record>" << endl;
}

void DaqXmlStream::dumpElement(const DataSeparatorRecord& record) const {
    dumpElement(record,
                emptyString);
}

void DaqXmlStream::dumpElement(const DataSeparatorRecord& record,
                               const string& indent) const {
    if (m_strict) {
        string nestedIndent = indent + (*m_indent);
        (*m_output) << indent << "<data_separator_record block_number=\"" << record.blockNumber();
        (*m_output) << "\" block_length=\"" << record.blockLength();
        (*m_output) << "\" size=\"" << record.size() << "\">" << endl;
    }
}

void DaqXmlStream::dumpElement(const CalibrationParametersRecord& record) const {
    dumpElement(record,
                emptyString);
}

void DaqXmlStream::dumpElement(const CalibrationParametersRecord& record,
                               const string& indent) const {
    string nestedIndent = indent + (*m_indent);
    (*m_output) << indent << "<calibration_parameters_record>" << endl;
    (*m_output) << nestedIndent << "<detector>" << record.detector() << "</detector>" << endl;
    (*m_output) << nestedIndent << "<axis>" << record.axis() << "</axis>" << endl;
    (*m_output) << nestedIndent << "<source>" << record.source() << "</source>" << endl;
    (*m_output) << nestedIndent << "<z_position>" << record.zPosition() << "</z_position>" << endl;
    (*m_output) << nestedIndent << "<duration>" << record.duration() << "</duration>" << endl;
    (*m_output) << nestedIndent << "<led_frequency>" << record.ledFrequency() << "</led_frequency>" << endl;
    (*m_output) << nestedIndent << "<ltb_mode>" << record.ltbMode() << "</ltb_mode>" << endl;
    (*m_output) << indent << "</calibration_parameters_record>" << endl;
}

void DaqXmlStream::dumpElement(const RunParametersRecord& record) const {
    dumpElement(record,
                emptyString);
}

void DaqXmlStream::dumpElement(const RunParametersRecord& record,
                               const string& indent) const {
    const FileTraits& traits = record.fileTraits();
    string nestedIndent = indent + (*m_indent);
    string doubleIndent = nestedIndent + (*m_indent);
    (*m_output) << indent << "<run_parameters_record";
    if (m_strict) {
        (*m_output) << " size=\"" << record.size() << "\"";
    }
    (*m_output) << ">" << endl;
    (*m_output) << nestedIndent << "<run>" << record.runNumber() << "</run>" << endl;
    (*m_output) << nestedIndent << "<record_enabled>" << record.recordEnabled() << "</record_enabled>" << endl;
    const LtbTraits::TriggerLines* detectors = traits.detectorList(record.detectorMask());
    if (detectors->empty()) {
        (*m_output) << nestedIndent << "<detector_mask/>" << endl;
    } else {
        (*m_output) << nestedIndent << "<detector_mask>" << endl;
        LtbTraits::TriggerLines::const_iterator detector;
        for (detector = detectors->begin() ; detector != detectors->end() ; ++detector) {
            (*m_output) << doubleIndent  << "<" << *detector << "/>" << endl;
        }
        (*m_output) << nestedIndent << "</detector_mask>" << endl;
    }
    delete detectors;
    (*m_output) << indent << "</run_parameters_record>" << endl;
}

void DaqXmlStream::dumpElement(const MetadataStrings& record) const {
    dumpElement(record,
                emptyString);
}

void DaqXmlStream::dumpElement(const MetadataStrings& record,
                               const string& indent) const {
    string nestedIndent = indent + (*m_indent);
    const MetadataStrings::MetadataStringPtrList& strings = record.metadataStrings();
    (*m_output) << indent << "<metadata_strings";
    if (m_strict) {
        (*m_output) << " size=\"" << record.size() << "\"";
        (*m_output) << " string_count=\"" << strings.size() << "\"";
    }
    (*m_output) << ">" << endl;
    MetadataStrings::MetadataStringPtrList::const_iterator entry;
    for (entry = strings.begin();
         entry != strings.end();
         ++entry) {
        (*m_output) << nestedIndent << "<tag>" << (*entry)->first << "</tag>" << endl;
        (*m_output) << nestedIndent << "<value>" << (*entry)->second << "</value>" << endl;
    }
    (*m_output) << indent << "</metadata_strings>" << endl;
}

void DaqXmlStream::dumpElement(const FileNameStrings& record) const {
    dumpElement(record,
                emptyString);
}

void DaqXmlStream::dumpElement(const FileNameStrings& record,
                               const string& indent) const {
    string nestedIndent = indent + (*m_indent);
    (*m_output) << indent << "<file_name_strings";
    if (m_strict) {
        (*m_output) << " size=\"" << record.size() << "\"";
    }
    (*m_output) << ">" << endl;
    (*m_output) << nestedIndent << "<application>" << record.application() << "</application>" << endl;
    (*m_output) << nestedIndent << "<file_base>" << record.fileBase() << "</file_base>" << endl;
    (*m_output) << indent << "</file_name_strings>" << endl;
}

void DaqXmlStream::dumpElement(const FileStartRecord& record) const {
    dumpElement(record,
                emptyString);
}

void DaqXmlStream::dumpElement(const FileStartRecord& record,
                               const string& indent) const {
    const FileTraits& traits = record.fileTraits();
    string nestedIndent = indent + (*m_indent);
    (*m_output) << indent << "<file_start_record format=\"" << record.majorVersion() << "." << record.minorVersion();
    if (m_strict) {
        (*m_output) << "\" size=\"" << record.size();
    }
    (*m_output) << "\">" << endl;
    (*m_output) << nestedIndent << "<file_number>" << record.fileNumber() << "</file_number>" << endl;
    (*m_output) << nestedIndent << "<time>" << traits.dateTimeAsString(record.dateTime()) << "</time>" << endl;
    (*m_output) << nestedIndent << "<data_block_limit>" << record.dataBlockLimit() << "</data_block_limit>" << endl;
    (*m_output) << nestedIndent << "<megabyte_limit>" << record.megabyteLimit() << "</megabyte_limit>" << endl;
    (*m_output) << indent << "</file_start_record>" << endl;
}

void DaqXmlStream::dumpElement(const FileBuffer& record) const {
    dumpElement(record,
                emptyString);
}

void DaqXmlStream::dumpElement(const FileBuffer& record,
                               const string& indent) const {
    if (record.isMarked(FileTraits::kFileStartRecord)) {
        const FileStartRecord* fileStartRecord = dynamic_cast<const FileStartRecord*>(&record);
        dumpElement(*fileStartRecord,
                    indent);
    } else if (record.isMarked(FileTraits::kFileNameStrings)) {
        const FileNameStrings* fileNameStrings = dynamic_cast<const FileNameStrings*>(&record);
        dumpElement(*fileNameStrings,
                    indent);
    } else if (record.isMarked(FileTraits::kMetadataStrings)) {
        const MetadataStrings* metadataStrings = dynamic_cast<const MetadataStrings*>(&record);
        dumpElement(*metadataStrings,
                    indent);
    } else if (record.isMarked(FileTraits::kRunParametersRecord)) {
        const RunParametersRecord* runParametersRecord = dynamic_cast<const RunParametersRecord*>(&record);
        dumpElement(*runParametersRecord,
                    indent);
    } else if (record.isMarked(FileTraits::kCalibrationParametersRecord)) {
        const CalibrationParametersRecord* calibrationParametersRecord = dynamic_cast<const CalibrationParametersRecord*>(&record);
        dumpElement(*calibrationParametersRecord,
                    indent);
    } else if (record.isMarked(FileTraits::kDataSeparatorRecord)) {
        const DataSeparatorRecord* dataSeparatorRecord = dynamic_cast<const DataSeparatorRecord*>(&record);
        dumpElement(*dataSeparatorRecord,
                    indent);
    } else if (record.isMarked(FileTraits::kFileEndRecord)) {
        const FileEndRecord* fileEndRecord = dynamic_cast<const FileEndRecord*>(&record);
        dumpElement(*fileEndRecord,
                    indent);
    }
}

---