In This Package:

DaqPmtCrate.cc

Go to the documentation of this file.

/*
 *  DaqPmtCrate.cc
 *  DaqEvent
 *
 *  Created by Simon Patton on 9/2/2010.
 *  Copyright 2010 DayaBay Collaboration. All rights reserved.
 *
 */
#include "Event/DaqPmtCrate.h"

#include "Event/DaqFadcChannel.h"
#include "Event/DaqPmtChannel.h"
#include "EventReadoutFormat/EventHeader.h"
#include "EventReadoutFormat/EventTraits.h"
#include "EventReadoutFormat/RomFragment.h"
#include "EventReadoutFormat/RomHeader.h"
#include "FadcReadoutFormat/FadcData.h"
#include "FadcReadoutFormat/FadcReadout.h"
#include "FadcReadoutFormat/FadcTraits.h"
#include "FeeReadoutFormat/FeeHit.h"
#include "FeeReadoutFormat/FeeReadout.h"
#include "FeeReadoutFormat/FeeTraits.h"

using DayaBay::DaqFadcChannel;
using DayaBay::DaqLtb;
using DayaBay::DaqPmtChannel;
using DayaBay::DaqPmtCrate;
using DybDaq::EventHeader;
using DybDaq::EventReadout;
using DybDaq::EventTraits;
using DybDaq::FadcData;
using DybDaq::FadcReadout;
using DybDaq::FadcTraits;
using DybDaq::FeeHit;
using DybDaq::FeeReadout;
using DybDaq::FeeTraits;
using DybDaq::RomFragment;
using DybDaq::RomHeader;

static const unsigned int kMaxSlotCount = 22;
static const unsigned int kMaxChannelCount = 32;
static const unsigned int kUninitializedChannel = 0xffffffffU;

static const unsigned int kFeeConnectorOffset = 1;
static const unsigned int kFadcConnectorOffset = 17;


DaqPmtCrate::DaqPmtCrate(const Detector& detector,
                         const unsigned int run,
                         const unsigned int event) :
    DaqCrate(detector,
             run,
             event),
    m_pmtChannelPtrs(0),
    m_pmtIndices(0),
    m_feeReadouts(new FeeReadout*[kMaxSlotCount]),
    m_fadcChannelPtrs(0),
    m_fadcIndices(0),
    m_fadcReadouts(new FadcReadout*[kMaxSlotCount]) {
    for (unsigned int channel = 0;
         kMaxSlotCount != channel;
         ++channel) {
        m_feeReadouts[channel] = 0;
    }
}

DaqPmtCrate::DaqPmtCrate(const EventReadout* eventReadout) :
    DaqCrate(eventReadout),
    m_pmtChannelPtrs(0),
    m_pmtIndices(0),
    m_feeReadouts(0),
    m_fadcChannelPtrs(0),
    m_fadcIndices(0),
    m_fadcReadouts(0) {
}

DaqPmtCrate::DaqPmtCrate(const DaqPmtCrate& crate) :
    DaqCrate(crate),
    m_pmtChannelPtrs(0),
    m_pmtIndices(0),
    m_feeReadouts(0),
    m_fadcChannelPtrs(0),
    m_fadcIndices(0),
    m_fadcReadouts(0) {
}

DaqPmtCrate::~DaqPmtCrate() {
    flushCache();
}

DaqPmtCrate& DaqPmtCrate::operator=(const DaqPmtCrate & rhs) {
  if (this != &rhs) {
      flushCache();
      DaqCrate::operator=(rhs);
      m_pmtChannelPtrs = 0;
      m_pmtIndices = 0;
      m_feeReadouts = 0;
      m_fadcChannelPtrs = 0;
      m_fadcIndices = 0;
      m_fadcReadouts = 0;
  }
  return *this;
}

void DaqPmtCrate::flushCache() {
    if (0 != m_fadcReadouts) {
        // Fadceadouts are own by the EventReadout.
        delete[] m_fadcReadouts;
    }
    if (0 != m_fadcIndices) {
        for (unsigned int slot = 0;
             slot != kMaxSlotCount;
             ++slot) {
            FadcChannelPtrList::size_type* indicesInSlot = m_fadcIndices[slot];
            if (0 != indicesInSlot) {
                delete[] indicesInSlot;
            }
        }
        delete[] m_fadcIndices;
    }
    if (0 != m_fadcChannelPtrs) {
        FadcChannelPtrList::iterator finished = m_fadcChannelPtrs->end();
        for(FadcChannelPtrList::iterator readout = m_fadcChannelPtrs->begin();
            readout != finished;
            ++readout) {
            delete (*readout);
        }
        delete m_fadcChannelPtrs;
    }

    if (0 != m_feeReadouts) {
        // FeeReadouts are own by the EventReadout.
        delete[] m_feeReadouts;
    }
    if (0 != m_pmtIndices) {
        for (unsigned int slot = 0;
             slot != kMaxSlotCount;
             ++slot) {
            PmtChannelPtrList::size_type* indicesInSlot = m_pmtIndices[slot];
            if (0 != indicesInSlot) {
                delete[] indicesInSlot;
            }
        }
        delete[] m_pmtIndices;
    }
    if (0 != m_pmtChannelPtrs) {
        PmtChannelPtrList::iterator finished = m_pmtChannelPtrs->end();
        for(PmtChannelPtrList::iterator readout = m_pmtChannelPtrs->begin();
            readout != finished;
            ++readout) {
            delete (*readout);
        }
        delete m_pmtChannelPtrs;
    }
}

bool DaqPmtCrate::freshPmtAttributes() const {
    if (0 != m_pmtChannelPtrs) {
        return false;
    }

    PmtChannelPtrList** pmtChannelPtrs = const_cast<PmtChannelPtrList**>(&m_pmtChannelPtrs);
    *(pmtChannelPtrs) = new PmtChannelPtrList();

    PmtChannelPtrList::size_type*** pmtIndicesInSlot = const_cast<PmtChannelPtrList::size_type***>(&m_pmtIndices);
    *(pmtIndicesInSlot) = new PmtChannelPtrList::size_type*[kMaxSlotCount];
    for (unsigned int slot = 0;
         slot != kMaxSlotCount;
         ++slot) {
        (*(pmtIndicesInSlot))[slot] = 0;
    }

    return true;
}

bool DaqPmtCrate::freshFadcAttributes() const {
    if (0 != m_fadcChannelPtrs) {
        return false;
    }

    FadcChannelPtrList** fadcChannelPtrs = const_cast<FadcChannelPtrList**>(&m_fadcChannelPtrs);
    *(fadcChannelPtrs) = new FadcChannelPtrList();

    FadcChannelPtrList::size_type*** fadcIndicesInSlot = const_cast<FadcChannelPtrList::size_type***>(&m_fadcIndices);
    *(fadcIndicesInSlot) = new FadcChannelPtrList::size_type*[kMaxSlotCount];
    for (unsigned int slot = 0;
         slot != kMaxSlotCount;
         ++slot) {
        (*(fadcIndicesInSlot))[slot] = 0;
    }

    return true;
}

const DaqLtb& DaqPmtCrate::localTriggerBoard() const {
    return ltb();
}

const DaqPmtCrate::PmtChannelPtrList& DaqPmtCrate::channelReadouts() const {
    return pmtChannelReadouts();
}

const DaqPmtCrate::PmtChannelPtrList& DaqPmtCrate::pmtChannelReadouts() const {
    const EventReadout& daqReadout = eventReadout();
    if (0 == &daqReadout) {
        return *((PmtChannelPtrList*)0);
    }

    if (freshPmtAttributes()) {
        const Detector zzub = detector();
        const EventHeader& eventHeader = daqReadout.header();
        const EventTraits& traits = eventHeader.eventTraits();
        const unsigned int kFeeModuleType = traits.moduleType(EventTraits::kFeeModule);
        const EventReadout::RomFragmentPtrList& fragments = daqReadout.romFragments();
        for (EventReadout::RomFragmentPtrList::const_iterator fragment = fragments.begin();
             fragment != fragments.end();
             ++fragment) {
            const RomHeader& header = (*fragment)->header();
            if (kFeeModuleType == header.moduleType()) {
                const FeeReadout& readout = dynamic_cast<const FeeReadout&>((*fragment)->unwrappedData());
                const FeeReadout::FeeHitPtrList& hits = readout.feeHits();
                const unsigned int slot = header.slot();
                for (FeeReadout::FeeHitPtrList::const_iterator hitPtr = hits.begin();
                     hitPtr != hits.end();
                     ++hitPtr) {
                    const unsigned int channelNumber = (*hitPtr)->channelId();
                    PmtChannelPtrList::size_type* indices = pmtIndicesForSlot(slot);
                    const unsigned int index = indices[channelNumber];
                    if (kUninitializedChannel == index) {
                        indices[channelNumber] = m_pmtChannelPtrs->size();
                        m_pmtChannelPtrs->push_back(new DaqPmtChannel(*(*hitPtr),
                                                                   FeeChannelId(slot,
                                                                                channelNumber + kFeeConnectorOffset,
                                                                                zzub.site(),
                                                                                zzub.detectorId())));
                    } else {
                        (m_pmtChannelPtrs->at(index))->addHit(*(*hitPtr));
                    }
                }
            }
        }
    }
    return *m_pmtChannelPtrs;
}

bool DaqPmtCrate::hasChannel(const FeeChannelId& channelId) const {
    pmtChannelReadouts();
    PmtChannelPtrList::size_type* indices = pmtIndicesForSlot(channelId.board());
    const unsigned int index = indices[channelId.connector() - kFeeConnectorOffset];
    return kUninitializedChannel != index;
}

const DaqPmtChannel& DaqPmtCrate::channel(const FeeChannelId& channelId) const {
    pmtChannelReadouts();
    PmtChannelPtrList::size_type* indices = pmtIndicesForSlot(channelId.board());
    const unsigned int channelNumber = channelId.connector() - kFeeConnectorOffset;
    if (kMaxChannelCount <= channelNumber) {
        return *((DaqPmtChannel*)0);
    }
    const unsigned int index = indices[channelNumber];
    if (kUninitializedChannel == index) {
        return *((DaqPmtChannel*)0);
    }
    return *(m_pmtChannelPtrs->at(index));    
}

DaqPmtChannel& DaqPmtCrate::channel(const FeeChannelId& channelId) {
    const unsigned int slot = channelId.board();
    FeeReadout* readout = m_feeReadouts[slot];
    if (0 == readout) {
        readout = new FeeReadout(localTriggerNumber(),
                                 triggerType(),
                                 false,
                                 false,
                                 FeeTraits::defaultTraits());
        m_feeReadouts[slot] = readout;
        eventReadout().addReadout(readout,
                                  slot);
    }

    PmtChannelPtrList::size_type* indices = pmtIndicesForSlot(slot);
    const unsigned int channelNumber = channelId.connector() - kFeeConnectorOffset;
    if (kMaxChannelCount <= channelNumber) {
        return *((DaqPmtChannel*)0);
    }
    const unsigned int index = indices[channelNumber];
    if (kUninitializedChannel == index) {
        indices[channelNumber] = m_pmtChannelPtrs->size();
        DaqPmtChannel* channel = new DaqPmtChannel(channelId,
                                                   *readout);
        m_pmtChannelPtrs->push_back(channel);
        return *channel;
    }
    return *(m_pmtChannelPtrs->at(index));
}


DaqPmtCrate::PmtChannelPtrList::size_type* DaqPmtCrate::pmtIndicesForSlot(const unsigned int slot) const {
    if (kMaxSlotCount <= slot) {
        return 0;
    }

    freshPmtAttributes();
    PmtChannelPtrList::size_type* result = m_pmtIndices[slot];
    if (0 == result) {
        result = new PmtChannelPtrList::size_type[kMaxChannelCount];
        m_pmtIndices[slot] = result;
        for (unsigned int channel = 0;
             channel != kMaxChannelCount;
             ++channel) {
            result[channel] = kUninitializedChannel;
        }
    }
    return result;
}

const DaqPmtCrate::FadcChannelPtrList& DaqPmtCrate::fadcChannelReadouts() const {
    const EventReadout& daqReadout = eventReadout();
    if (0 == &daqReadout) {
        return *((FadcChannelPtrList*)0);
    }

    if (freshFadcAttributes()) {
        const Detector zzub = detector();
        const EventHeader& eventHeader = daqReadout.header();
        const EventTraits& traits = eventHeader.eventTraits();
        const unsigned int kFadcModuleType = traits.moduleType(EventTraits::kFadcModule);
        const EventReadout::RomFragmentPtrList& fragments = daqReadout.romFragments();
        for (EventReadout::RomFragmentPtrList::const_iterator fragment = fragments.begin();
             fragment != fragments.end();
             ++fragment) {
            const RomHeader& header = (*fragment)->header();
            if (kFadcModuleType == header.moduleType()) {
                const FadcReadout& readout = dynamic_cast<const FadcReadout&>((*fragment)->unwrappedData());
                const FadcReadout::FadcDataPtrList& data = readout.fadcData();
                const unsigned int slot = header.slot();
                for (FadcReadout::FadcDataPtrList::const_iterator dataPtr = data.begin();
                     dataPtr != data.end();
                     ++dataPtr) {
                    const unsigned int channelNumber = (*dataPtr)->channelId();
                    FadcChannelPtrList::size_type* indices = fadcIndicesForSlot(slot);
                    const unsigned int index = indices[channelNumber];
                    if (kUninitializedChannel == index) {
                        indices[channelNumber] = m_fadcChannelPtrs->size();
                        m_fadcChannelPtrs->push_back(new DaqFadcChannel(*(*dataPtr),
                                                                        FadcChannelId(slot,
                                                                                      channelNumber + kFadcConnectorOffset,
                                                                                      zzub.site(),
                                                                                      zzub.detectorId())));
                    } else {
                        (m_fadcChannelPtrs->at(index))->addData(*(*dataPtr));
                    }
                }
            }
        }
    }
    return *m_fadcChannelPtrs;
}

bool DaqPmtCrate::hasChannel(const FadcChannelId& channelId) const {
    FadcChannelPtrList::size_type* indices = fadcIndicesForSlot(channelId.board());
    const unsigned int index = indices[channelId.connector() - kFadcConnectorOffset];
    return kUninitializedChannel != index;
}

const DaqFadcChannel& DaqPmtCrate::channel(const FadcChannelId& channelId) const {
    FadcChannelPtrList::size_type* indices = fadcIndicesForSlot(channelId.board());
    const unsigned int channelNumber = channelId.connector() - kFadcConnectorOffset;
    if (kMaxChannelCount <= channelNumber) {
        return *((DaqFadcChannel*)0);
    }
    const unsigned int index = indices[channelNumber];
    if (kUninitializedChannel == index) {
        return *((DaqFadcChannel*)0);
    }
    return *(m_fadcChannelPtrs->at(index));    
}

DaqFadcChannel& DaqPmtCrate::channel(const FadcChannelId& channelId) {
    const unsigned int slot = channelId.board();
    FadcReadout* readout = m_fadcReadouts[slot];
    if (0 == readout) {
        readout = new FadcReadout(localTriggerNumber(),
                                  triggerType(),
                                  false,
                                  FadcTraits::defaultTraits());
        m_fadcReadouts[slot] = readout;
        eventReadout().addReadout(readout,
                                  slot);
    }

    FadcChannelPtrList::size_type* indices = fadcIndicesForSlot(slot);
    const unsigned int channelNumber = channelId.connector() - kFadcConnectorOffset;
    if (kMaxChannelCount <= channelNumber) {
        return *((DaqFadcChannel*)0);
    }
    const unsigned int index = indices[channelNumber];
    if (kUninitializedChannel == index) {
        indices[channelNumber] = m_fadcChannelPtrs->size();
        DaqFadcChannel* channel = new DaqFadcChannel(channelId,
                                                   *readout);
        m_fadcChannelPtrs->push_back(channel);
        return *channel;
    }
    return *(m_fadcChannelPtrs->at(index));
}

DaqPmtCrate::FadcChannelPtrList::size_type* DaqPmtCrate::fadcIndicesForSlot(const unsigned int slot) const {
    if (kMaxSlotCount <= slot) {
        return 0;
    }

    freshFadcAttributes();
    FadcChannelPtrList::size_type* result = m_fadcIndices[slot];
    if (0 == result) {
        result = new FadcChannelPtrList::size_type[kMaxChannelCount];
        m_fadcIndices[slot] = result;
        for (unsigned int channel = 0;
             channel != kMaxChannelCount;
             ++channel) {
            result[channel] = kUninitializedChannel;
        }
    }
    return result;
}

---