In This Package:

DaqBenchmark.cc

Go to the documentation of this file.

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

#include <ctime>
#include <sstream>

#include "TH2.h"

#include "Conventions/Electronics.h"
#include "DaqXml/DaqXmlStream.h"
#include "DaqReadoutFormat/RomData.h"
#include "Event/DaqCrate.h"
#include "Event/DaqFadcChannel.h"
#include "Event/DaqLtb.h"
#include "Event/DaqLtbFrame.h"
#include "Event/DaqPmtChannel.h"
#include "Event/DaqPmtCrate.h"
#include "Event/Readout.h"
#include "Event/ReadoutHeader.h"
#include "Event/ReadoutPmtChannel.h"
#include "Event/ReadoutPmtCrate.h"
#include "EventReadoutFormat/EventHeader.h"
#include "EventReadoutFormat/EventReadout.h"
#include "EventReadoutFormat/EventTraits.h"
#include "EventReadoutFormat/RomFragment.h"
#include "EventReadoutFormat/RomHeader.h"
#include "FeeReadoutFormat/FeeHit.h"
#include "FeeReadoutFormat/FeeReadout.h"
#include "FileReadoutFormat/DataSeparatorRecord.h"
#include "FileReadoutFormat/FileBuffer.h"
#include "FileReadoutFormat/FileTraits.h"
#include "LtbReadoutFormat/LtbFrame.h"
#include "LtbReadoutFormat/LtbReadout.h"
#include "LtbReadoutFormat/LtbTime.h"
#include "StatisticsSvc/IStatisticsSvc.h"

using DayaBay::FadcChannelId;
using DayaBay::FeeChannelId;
using DayaBay::DaqCrate;
using DayaBay::DaqFadcChannel;
using DayaBay::DaqLtb;
using DayaBay::DaqLtbFrame;
using DayaBay::DaqPmtChannel;
using DayaBay::DaqPmtCrate;
using DayaBay::Readout;
using DayaBay::ReadoutHeader;
using DayaBay::ReadoutPmtChannel;
using DayaBay::ReadoutPmtCrate;
using DybDaq::DataSeparatorRecord;
using DybDaq::EventHeader;
using DybDaq::EventReadout;
using DybDaq::EventTraits;
using DybDaq::FeeHit;
using DybDaq::FeeReadout;
using DybDaq::FileBuffer;
using DybDaq::FileTraits;
using DybDaq::RomData;
using DybDaq::RomFragment;
using DybDaq::RomHeader;
using DybDaq::LtbFrame;
using DybDaq::LtbReadout;
using DybDaq::LtbTime;

using std::string;
using std::stringstream;

static const string i("  ");
static const unsigned int kMaxSlotCount = 22U;
static const unsigned int kMaxFeeChannelCount = 32U;
static const unsigned int kBytesInInt = 4U;

#define TIME_T_BUILTIN_TYPE unsigned long

DaqBenchmark::DaqBenchmark(const string& name, 
                           ISvcLocator* pSvcLocator) :
    GaudiAlgorithm(name,
                   pSvcLocator),
    m_statsSvc(0),
    m_feeLowGainHistograms( new TH1F**[kMaxSlotCount]),
    m_feeHighGainHistograms( new TH1F**[kMaxSlotCount]),
    m_feeTdcHistograms( new TH1F**[kMaxSlotCount]),
    m_fadcHistograms( new TH2F**[kMaxSlotCount]),
    m_eventCount(0),
    m_payloadLength(0),
    m_beginTime(0),
    m_firstEventTime(0),
    m_lastEventTime(0) {
    for(unsigned int slot = 0;
        slot != kMaxSlotCount;
        ++slot) {
        m_feeLowGainHistograms[slot] = 0;
        m_feeHighGainHistograms[slot] = 0;
        m_feeTdcHistograms[slot] = 0;
        m_fadcHistograms[slot] = 0;
    }
    declareProperty("UseDaqFormat",
                    m_useDaqFormat=true,
                    "True is the benchmarks should us the DaqFormat products");
    declareProperty("UseDaqEvent",
                    m_useDaqEvent=false,
                    "True is the benchmarks should us the DaqEvent products");
    declareProperty("UseReadoutEvent",
                    m_useReadoutEvent=false,
                    "True is the benchmarks should us the ReadoutEvent products");
}

DaqBenchmark::~DaqBenchmark() {
    // Histograms are cleaned up by Stats service.
}

StatusCode DaqBenchmark::initialize()
{
    StatusCode sc = service("StatisticsSvc",
                            m_statsSvc,
                            true);
    if (sc.isFailure()) {
        error() << "Failed to get StatisticsSvc" << endreq;
        return sc;
    }
    m_beginTime = time(0);
    return sc;
}

StatusCode DaqBenchmark::finalize()
{
    if (m_lastEventTime != m_firstEventTime) {
        time_t now = time(0);
        const double moduleDelta = difftime(now,
                                            m_beginTime);
        const double eventDelta = difftime(m_lastEventTime,
                                           m_firstEventTime);
        info() << "Benchmark factor for this job was " << std::setprecision(2) << (moduleDelta/ eventDelta) << "." << endreq;
        info() << "Analysis byte rate was " << std::setprecision(2) << (m_payloadLength / (moduleDelta * 1024U * 1024U)) << " MB/s." << endreq;
        info() << "Data taking event rate was " << std::setprecision(4) << ((m_eventCount - 1) / eventDelta) << " Hz." << endreq;
        info() << "Analysis event rate was " << std::setprecision(4) << ((m_eventCount - 1) / moduleDelta) << " Hz." << endreq;
    }

    if( m_statsSvc ) {
        m_statsSvc->release();
    }
    return StatusCode::SUCCESS;
}

StatusCode DaqBenchmark::execute() {
    const ReadoutHeader* readoutHeader = get<ReadoutHeader>("/Event/Readout/ReadoutHeader");
    if (0 == readoutHeader) {
        error() << "Failed to get readout header." << endreq;
        return StatusCode::FAILURE;
    }

    if (m_useDaqFormat) {
        StatusCode sc = handleDaqFormat(*readoutHeader);
        if (sc.isFailure()) {
            return sc;
        }
    }
    if (m_useDaqEvent) {
        StatusCode sc = handleDaqEvent(*readoutHeader);
        if (sc.isFailure()) {
            return sc;
        }
    }
    if (m_useReadoutEvent) {
        StatusCode sc = handleReadoutEvent(*readoutHeader);
        if (sc.isFailure()) {
            return sc;
        }
    }
    ++m_eventCount;
    if (0 == (m_eventCount % 1000)) {
        info() << " Processed " << m_eventCount << " events" << endreq;
    }
    return StatusCode::SUCCESS;
}

TH1F** DaqBenchmark::getSlotLowGainHistograms(const unsigned int slot) {
    return getSlotHistogram(m_feeLowGainHistograms,
                            slot); 
}

TH1F** DaqBenchmark::getSlotHighGainHistograms(const unsigned int slot) {
    return getSlotHistogram(m_feeHighGainHistograms,
                            slot); 
}

TH1F** DaqBenchmark::getSlotTdcHistograms(const unsigned int slot) {
    return getSlotHistogram(m_feeTdcHistograms,
                            slot);
}

TH1F** DaqBenchmark::getSlotHistogram(TH1F*** histograms,
                                      const unsigned int slot) {
    TH1F** result = histograms[slot];
    if (0 == result) {
        result = new TH1F*[kMaxFeeChannelCount];
        histograms[slot] = result;
        for (unsigned int channel = 0;
             channel != kMaxFeeChannelCount;
             ++channel) {
            result[channel] = 0;
        }
    }
    return result;
}

TH2F** DaqBenchmark::getSlotFadcHistograms(const unsigned int slot) {
    return getSlotHistogram(m_fadcHistograms,
                            slot);
}

TH2F** DaqBenchmark::getSlotHistogram(TH2F*** histograms,
                                      const unsigned int slot) {
    TH2F** result = histograms[slot];
    if (0 == result) {
        result = new TH2F*[kMaxFeeChannelCount];
        histograms[slot] = result;
        for (unsigned int channel = 0;
             channel != kMaxFeeChannelCount;
             ++channel) {
            result[channel] = 0;
        }
    }
    return result;
}

static const string getName(const string& field,
                            const unsigned int slot,
                            const unsigned int channelId) {
    // Construct histogram name in statistics service
    stringstream name;
    name << field << " for slot_" << std::setfill('0') << std::setw(2) << slot
         << "_channel_" << std::setfill('0') << std::setw(2) << channelId;
    return name.str();
}

static const string getPath(const unsigned int slot,
                            const unsigned int channelId, 
                            const char* name) {
    // Construct histogram path in statistics service
    stringstream path;
    path << "/file0//benchmark"
         << "/slot_" << std::setfill('0') << std::setw(2) << slot
         << "/channel_" << std::setfill('0') << std::setw(2) << channelId
         << "/" << name;
    return path.str();
}

TH1F* DaqBenchmark::getLowGainHistogram(TH1F** slotLowGainHistograms,
                                          const unsigned int slot,
                                          const unsigned int channelNumber) {
    TH1F* result = slotLowGainHistograms[channelNumber];
    if (0 == result) {
        const string name = getName("Low Gain ADC",
                                    slot,
                                    channelNumber);
        result = new TH1F(name.c_str(),
                          "ADC, low gain",
                          4096,
                          0,
                          4096);
        slotLowGainHistograms[channelNumber] = result;
        m_statsSvc->put(getPath(slot,
                                channelNumber,
                                name.c_str()), 
                        result);
    }
    return result;
}

TH1F* DaqBenchmark::getHighGainHistogram(TH1F** slotHighGainHistograms,
                                         const unsigned int slot,
                                         const unsigned int channelNumber) {
    TH1F* result = slotHighGainHistograms[channelNumber];
    if (0 == result) {
        const string name = getName("High Gain ADC",
                                    slot,
                                    channelNumber);
        result = new TH1F(name.c_str(),
                          "ADC, high gain",
                          4096,
                          0,
                          4096);
        slotHighGainHistograms[channelNumber] = result;
        m_statsSvc->put(getPath(slot,
                                channelNumber,
                                name.c_str()), 
                        result);
    }
    return result;
}

TH1F* DaqBenchmark::getTdcHistogram(TH1F** slotTdcHistograms,
                                    const unsigned int slot,
                                    const unsigned int channelNumber) {
    TH1F* result = slotTdcHistograms[channelNumber];
    if (0 == result) {
        const string name = getName("TDC",
                                    slot,
                                    channelNumber);
        result = new TH1F(name.c_str(),
                          "TDC",
                          1000,
                          300,
                          1300);
        slotTdcHistograms[channelNumber] = result;
        m_statsSvc->put(getPath(slot,
                                channelNumber,
                                name.c_str()), 
                        result);
    }
    return result;
}

TH2F* DaqBenchmark::getFadcHistogram(TH2F** slotFadcHistograms,
                                     const unsigned int slot,
                                     const unsigned int channelNumber) {
    TH2F* result = slotFadcHistograms[channelNumber];
    if (0 == result) {
        const string name = getName("FADC",
                                    slot,
                                    channelNumber);
        result = new TH2F(name.c_str(),
                          "FADC",
                          0,
                          120,
                          120,
                          0,
                          256,
                          256);
        slotFadcHistograms[channelNumber] = result;
        m_statsSvc->put(getPath(slot,
                                channelNumber,
                                name.c_str()), 
                        result);
    }
    return result;
}

static const time_t getEventTime(const EventReadout& event) {
    const EventReadout::RomFragmentPtrList& fragments = event.romFragments();
    unsigned int ltbModuleType = event.header().eventTraits().moduleType(EventTraits::kLtbModule);
    EventReadout::RomFragmentPtrList::const_iterator fragment = fragments.begin();
    while((ltbModuleType != ((*fragment)->header().moduleType()))
          && fragment != fragments.end()) {
        ++fragment;
    }
    if (fragment == fragments.end()) {
        return 0;
    }
    const LtbReadout& ltbReadout = dynamic_cast<const LtbReadout&>((*fragment)->unwrappedData());
    const LtbReadout::LtbFramePtrList& frames = ltbReadout.ltbFrames();
    if (0 == frames.size()) {
        return 0;
    }
    return (*(frames.begin()))->dateTime().unixTime();
}

StatusCode DaqBenchmark::handleDaqFormat(const ReadoutHeader& readoutHeader) {
    const EventReadout* event = 0;
    const DaqCrate* daqCrate = readoutHeader.daqCrate();
    if (0 == daqCrate) {
        const Readout* readout = readoutHeader.readout();
        if (0 == readout) {
            error() << "Failed to get DAQ readout or readout from header" << endreq;
            return StatusCode::FAILURE;
        }
        event = readout->eventReadout();
        if (0 == event) {
            error() << "Failed to get event readout from readout" << endreq;
            return StatusCode::FAILURE;
        }
    } else {
        event = &(daqCrate->eventReadout());
    }

    m_lastEventTime = getEventTime(*event);
    if (0 == m_firstEventTime) {
        m_firstEventTime = m_lastEventTime;
    }
    handleEvent(*event);
    m_payloadLength += event->header().totalSize() * kBytesInInt;
    return StatusCode::SUCCESS;
 }

void DaqBenchmark::handleEvent(const DybDaq::EventReadout& event) {
    const EventReadout::RomFragmentPtrList& fragments = event.romFragments();
    for (EventReadout::RomFragmentPtrList::const_iterator fragment = fragments.begin();
         fragment != fragments.end();
         ++fragment) {
        handleFragment(*(*fragment));
    }
}

void DaqBenchmark::handleFragment(const RomFragment& fragment) {
    const RomHeader& header = fragment.header();
    const unsigned int slot = header.slot();
    const unsigned int kFeeModuleType = header.eventTraits().moduleType(EventTraits::kFeeModule);
    if (kFeeModuleType == header.moduleType()) {
        handleFee(dynamic_cast<const FeeReadout&>(fragment.unwrappedData()),
                  slot);
    }
}

void DaqBenchmark::handleFee(const FeeReadout& readout,
                             const unsigned int slot) {
    TH1F** slotLowGainHistograms = getSlotLowGainHistograms(slot);
    TH1F** slotHighGainHistograms = getSlotHighGainHistograms(slot);
    TH1F** slotTdcHistograms = getSlotTdcHistograms(slot);

    const FeeReadout::FeeHitPtrList& hits = readout.feeHits();
    for (FeeReadout::FeeHitPtrList::const_iterator hitPtr = hits.begin();
         hitPtr != hits.end();
         ++hitPtr) {
        const FeeHit& hit = *(*hitPtr);
        const unsigned int channelNumber = hit.channelId() + 1;
        TH1F* rangeHistogram = 0;
        if (hit.isHighRangeAdc()) {
            rangeHistogram = getLowGainHistogram(slotLowGainHistograms,
                                                   slot,
                                                   channelNumber);
        } else {
            rangeHistogram = getHighGainHistogram(slotHighGainHistograms,
                                                  slot,
                                                  channelNumber);
        }
        rangeHistogram->Fill(hit.adc());
        TH1F* tdcHistogram = getTdcHistogram(slotTdcHistograms,
                                             slot,
                                             channelNumber);
        tdcHistogram->Fill(hit.tdc());
    }
}

static const time_t getEventTime(const TimeStamp& time) {
    time_t seconds = time.GetSec();
    return seconds;
}

StatusCode DaqBenchmark::handleReadoutEvent(const ReadoutHeader& readoutHeader) {
    const Readout* readout = readoutHeader.readout();
    if (0 == readout) {
        error() << "Failed to get readout from header" << endreq;
        return StatusCode::FAILURE;
    }

    m_lastEventTime = getEventTime(readout->triggerTime());
    if (0 == m_firstEventTime) {
        m_firstEventTime = m_lastEventTime;
    }
    const ReadoutPmtCrate* pmtReadout = dynamic_cast<const ReadoutPmtCrate*>(readout);
    if (0 != pmtReadout) {
        handleEvent(*pmtReadout);
    }
    return StatusCode::SUCCESS;
 }

void DaqBenchmark::handleEvent(const DayaBay::ReadoutPmtCrate& crate) {
    const std::vector<DayaBay::FeeChannelId> channels = const_cast<ReadoutPmtCrate&>(crate).channels();
    std::vector<DayaBay::FeeChannelId>::const_iterator finished = channels.end();
    for (std::vector<DayaBay::FeeChannelId>::const_iterator channel = channels.begin();
         channel != finished;
         ++channel) {
        handleChannel(const_cast<ReadoutPmtCrate&>(crate).channel(*channel));
    }
}

void DaqBenchmark::handleChannel(const ReadoutPmtChannel& channel) {
    const FeeChannelId& feeChannelId = channel.channelId();
    const unsigned int slot = feeChannelId.board();
    TH1F** slotLowGainHistograms = getSlotLowGainHistograms(slot);
    TH1F** slotHighGainHistograms = getSlotHighGainHistograms(slot);
    TH1F** slotTdcHistograms = getSlotTdcHistograms(slot);
  
    const unsigned int channelNumber = feeChannelId.connector();
    TH1F* lowGainHistogram = getLowGainHistogram(slotLowGainHistograms,
                                                 slot,
                                                 channelNumber);
    TH1F* highGainHistogram = getHighGainHistogram(slotHighGainHistograms,
                                                   slot,
                                                   channelNumber);
    unsigned int hit = 0;
    const std::vector<int>& charges = channel.adc();
    const std::vector<int>::const_iterator finishedCharges = charges.end();
    for(std::vector<int>::const_iterator charge = charges.begin();
        finishedCharges != charge;
        ++charge) {
        if (channel.adcRange(hit) == DayaBay::FeeGain::kHigh) {
            highGainHistogram->Fill(*charge);
        } else {
            lowGainHistogram->Fill(*charge);
        }
        ++hit;
    }

    TH1F* tdcHistogram = getTdcHistogram(slotTdcHistograms,
                                         slot,
                                         channelNumber);
    const std::vector<int>& times = channel.tdc();
    const std::vector<int>::const_iterator finishedTimes = times.end();
    for(std::vector<int>::const_iterator time = times.begin();
        finishedTimes != time;
        ++time) {
        tdcHistogram->Fill(*time);
    }
}

StatusCode DaqBenchmark::handleDaqEvent(const ReadoutHeader& readoutHeader) {
    const DaqCrate* daqCrate = readoutHeader.daqCrate();
    if (0 == daqCrate) {
        error() << "Failed to get readout from header" << endreq;
        return StatusCode::FAILURE;
    }

    m_lastEventTime = getEventTime(daqCrate->triggerTime());
    if (0 == m_firstEventTime) {
        m_firstEventTime = m_lastEventTime;
    }
    const DaqPmtCrate* pmtCrate = daqCrate->asPmtCrate();
    if (0 != pmtCrate) {
        handleEvent(*pmtCrate);
    }
    return StatusCode::SUCCESS;
 }

void DaqBenchmark::handleEvent(const DayaBay::DaqPmtCrate& crate) {
    {
        const DaqLtb& triggerBoard = crate.localTriggerBoard();
        const DaqLtb::LtbFramePtrList& frames = triggerBoard.frames();
        const DaqLtb::LtbFramePtrList::const_iterator finished = frames.end();
        for(DaqLtb::LtbFramePtrList::const_iterator frame = frames.begin();
            finished != frame;
            ++frame) {
            handleFrame(*(*frame));
        }
    }

    {
        const DaqPmtCrate::PmtChannelPtrList& channels = crate.pmtChannelReadouts();
        const DaqPmtCrate::PmtChannelPtrList::const_iterator finished = channels.end();
        for (DaqPmtCrate::PmtChannelPtrList::const_iterator channel = channels.begin();
             channel != finished;
             ++channel) {
            handleChannel(*(*channel));
        }
    }

    {
        const DaqPmtCrate::FadcChannelPtrList& channels = crate.fadcChannelReadouts();
        const DaqPmtCrate::FadcChannelPtrList::const_iterator finished = channels.end();
        for (DaqPmtCrate::FadcChannelPtrList::const_iterator channel = channels.begin();
             channel != finished;
             ++channel) {
            handleChannel(*(*channel));
        }
    }
}

void DaqBenchmark::handleFrame(const DaqLtbFrame& /* frame */) {
}

void DaqBenchmark::handleChannel(const DaqPmtChannel& channel) {
    const FeeChannelId& feeChannelId = channel.channelId();
    const unsigned int slot = feeChannelId.board();
    TH1F** slotLowGainHistograms = getSlotLowGainHistograms(slot);
    TH1F** slotHighGainHistograms = getSlotHighGainHistograms(slot);
    TH1F** slotTdcHistograms = getSlotTdcHistograms(slot);
    
    const unsigned int channelNumber = feeChannelId.connector();
    TH1F* lowGainHistogram = getLowGainHistogram(slotLowGainHistograms,
                                           slot,
                                           channelNumber);
    TH1F* highGainHistogram = getHighGainHistogram(slotHighGainHistograms,
                                                   slot,
                                                   channelNumber);
    TH1F* tdcHistogram = getTdcHistogram(slotTdcHistograms,
                                         slot,
                                         channelNumber);

    const unsigned int finished = channel.hitCount();
    for(unsigned int hit = 0;
        hit != finished;
        ++hit) {
        if (channel.isHighGainAdc(hit)) {
            highGainHistogram->Fill(channel.adc(hit));
        } else {
            lowGainHistogram->Fill(channel.adc(hit));
        }
        tdcHistogram->Fill(channel.tdc(hit));
    }
}

void DaqBenchmark::handleChannel(const DaqFadcChannel& channel) {
    const FadcChannelId& fadcChannelId = channel.channelId();
    const unsigned int slot = fadcChannelId.board();
    TH2F** slotFadcHistograms = getSlotFadcHistograms(slot);
    
    const unsigned int channelNumber = fadcChannelId.connector();
    TH2F* fadcHistogram = getFadcHistogram(slotFadcHistograms,
                                           slot,
                                           channelNumber);

    const DaqFadcChannel::FadcSamples& samples = channel.samples();
    unsigned int bin = 0;
    const DaqFadcChannel::FadcSamples::const_iterator finished = samples.end();
    for (DaqFadcChannel::FadcSamples::const_iterator sample = samples.begin();
         finished != sample;
         ++sample) {
        fadcHistogram->Fill(bin,
                            *sample,
                            1.0);
        ++bin;
    }
}

---