In This Package:

DaqCrate.cc

Go to the documentation of this file.

/*
 *  DaqCrate.cc
 *  DaqEvent
 *
 *  Created by Simon Patton on 81/1610.
 *  Copyright 2010 DayaBay Collaboration. All rights reserved.
 *
 */
#include "Event/DaqCrate.h"

#include "DaqReadoutFormat/ByteBuffer.h"
#include "DaqReadoutFormat/RomData.h"
#include "CbltReadoutFormat/CbltTraits.h"
#include "Event/DaqPmtCrate.h"
#include "Event/DaqLtb.h"
#include "EventReadoutFormat/EventHeader.h"
#include "EventReadoutFormat/EventTraits.h"
#include "EventReadoutFormat/RomFragment.h"
#include "EventReadoutFormat/RomHeader.h"
#include "LtbReadoutFormat/LtbReadout.h"

using DayaBay::DaqCrate;
using DayaBay::DaqPmtCrate;
using DayaBay::DaqLtb;
using DayaBay::DaqLtbFrame;
using DayaBay::Detector;
using DybDaq::ByteBuffer;
using DybDaq::CbltTraits;
using DybDaq::EventHeader;
using DybDaq::EventReadout;
using DybDaq::EventTraits;
using DybDaq::LtbReadout;
using DybDaq::RomData;
using DybDaq::RomFragment;
using DybDaq::RomHeader;

static DetectorId::DetectorId_t convertDetector(unsigned int daqDetectorId)
{
    // Convert detector definition from DAQ to Offline convention 
    switch(daqDetectorId){
    case 1:
        return DetectorId::kAD1;
    case 2:
        return DetectorId::kAD2;
    case 3:
        return DetectorId::kAD3;
    case 4:
        return DetectorId::kAD4;
    case 5:
        return DetectorId::kIWS;
    case 6:
        return DetectorId::kOWS;
    case 7:
        return DetectorId::kRPC;
    default:
        break;
    }
    return DetectorId::kUnknown;
}

static unsigned int convertDetectorId(DetectorId::DetectorId_t detectorId)
{
    // Convert detector definition from Offline convention to DAQ
    switch(detectorId){
    case DetectorId::kAD1:
        return 1;
    case DetectorId::kAD2:
        return 2;
    case DetectorId::kAD3:
        return 3;
    case DetectorId::kAD4:
        return 4;
    case DetectorId::kIWS:
        return 5;
    case DetectorId::kOWS:
        return 6;
    case DetectorId::kRPC:
        return 7;
    default:
        break;
    }
    return 0;
}

static Site::Site_t convertSite(unsigned int daqSiteId)
{
    // Convert site definition from DAQ to Offline convention 
    switch(daqSiteId){
    case 1:
        return Site::kDayaBay;
    case 2:
        return Site::kLingAo;
    case 3:
        return Site::kFar;
    case 4:
        return Site::kMid;
    case 6:
        return Site::kSAB;
    default:
        break;
    }
    return Site::kUnknown;
}

DaqCrate::DaqCrate(const Detector& detector,
                   const unsigned int run,
                   const unsigned int event) :
    m_detector(0),
    m_eventReadout(new EventReadout(convertSite(detector.site()),
                                    convertDetectorId(detector.detectorId()),
                                    run,
                                    event,
                                    0, // Normal data type
                                    false,
                                    false,
                                    false,
                                    CbltTraits::defaultTraits(),
                                    EventTraits::defaultTraits())),
    m_ltb(0) {
}

DaqCrate::DaqCrate(const EventReadout* eventReadout) :
    m_detector(0),
    m_eventReadout(const_cast<EventReadout*>(eventReadout)),
    m_ltb(0) {
}

DaqCrate::DaqCrate(const DaqCrate& crate):
    m_detector(0),
    m_eventReadout(0),
    m_ltb(0) {
    const EventReadout& readout = crate.eventReadout();
    // WARNING: NExt line will fail to work if EventReadout is not ByteBuffer based.
    m_eventReadout = new EventReadout(readout);
}

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

DaqCrate& DaqCrate::operator=(const DaqCrate& rhs) {
  if (this != &rhs) {
      flushCache();
      m_detector = 0;
      m_eventReadout = new EventReadout(rhs.eventReadout());
      m_ltb = 0;
  }
  return *this;
}

void DaqCrate::flushCache() {
    if (0 != m_ltb) {
        delete m_ltb;
    }
    if (0 != m_eventReadout) {
        delete m_eventReadout;
    }
    if (0 != m_detector) {
        delete m_detector;
    }
}

const DaqPmtCrate* DaqCrate::asPmtCrate() const {
    return dynamic_cast<const DaqPmtCrate*>(this);
}

unsigned int DaqCrate::eventNumber() const {
    return m_eventReadout->header().event();
}

const DybDaq::EventReadout& DaqCrate::eventReadout() const {
    return *m_eventReadout;
}

unsigned int DaqCrate::localTriggerNumber() const {
    const DaqLtb& localTriggerBoard = ltb();
    return localTriggerBoard.localTriggerNumber();
}

unsigned int DaqCrate::runNumber() const {
    return m_eventReadout->header().run();
}

const TimeStamp& DaqCrate::triggerTime() const {
    const DaqLtbFrame& frame = firstLtbFrame();
    return frame.triggerTime();
}

DayaBay::Trigger::TriggerType_t DaqCrate::triggerType() const {
    const DaqLtbFrame& frame = firstLtbFrame();
    // TODO: Chek whether this should be the sum of all frames?
    return frame.triggerType();
}

const Detector& DaqCrate::detector() const {
    if (0 == m_detector) {
        const EventHeader& header = m_eventReadout->header();
        Detector** detector = const_cast<Detector**>(&m_detector);
        *(detector) = new Detector(convertSite(header.site()),
                                   convertDetector(header.detector()));

    }
    return *m_detector;
}

const DaqLtbFrame& DaqCrate::firstLtbFrame() const {
    const DaqLtb& crateLtb = ltb();
    return crateLtb.firstFrame();
}

const DaqLtb& DaqCrate::ltb() const {
    if ( 0 == m_ltb) {
        if (0 == m_eventReadout) {
            return *((DaqLtb*)0);
        }
        const EventReadout::RomFragmentPtrList& fragments = m_eventReadout->romFragments();
        EventReadout::RomFragmentPtrList::const_iterator fragment = fragments.begin();
        unsigned int ltbModuleType = m_eventReadout->header().eventTraits().moduleType(EventTraits::kLtbModule);
        while((ltbModuleType != ((*fragment)->header().moduleType()))
              && fragment != fragments.end()) {
            ++fragment;
        }
        if (fragment == fragments.end()) {
            return *((DaqLtb*)0);
        }
        const RomData& romData = (*fragment)->unwrappedData();
        const DaqLtb** ltb = const_cast<const DaqLtb**>(&m_ltb);
        *(ltb) = new DaqLtb(dynamic_cast<const LtbReadout&>(romData),
                            detector());
    }
    return *m_ltb;
}

bool DaqCrate::addLtb(const DaqLtb* ltb,
                      const unsigned int slot) {
    if (0 != m_ltb) {
        return false;
    }
    m_ltb = ltb;
    eventReadout().addReadout(ltb->ltbReadout(),
                              slot);
    return true;
}

DybDaq::EventReadout& DaqCrate::eventReadout() {
    return *m_eventReadout;
}

---