In This Package:

DaqEventConverter.cc

Go to the documentation of this file.

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

#include "DaqFormatContext.h"
#include "DaqFormatConversionSvc.h"

#include "Conventions/Detectors.h"
#include "Event/DaqPmtCrate.h"
#include "Event/ReadoutHeader.h"
#include "Event/Readout.h"
#include "Event/ReadoutPmtCrate.h"
#include "Event/ReadoutRpcCrate.h"
#include "EventReadoutFormat/EventHeader.h"
#include "EventReadoutFormat/EventReadout.h"
#include "EventReadoutFormat/EventTraits.h"
#include "EventReadoutFormat/RomFragment.h"
#include "EventReadoutFormat/RomHeader.h"
#include "GaudiKernel/MsgStream.h"
#include "LtbReadoutFormat/LtbFrame.h"
#include "LtbReadoutFormat/LtbReadout.h"
#include "LtbReadoutFormat/LtbTime.h"

using DayaBay::DaqPmtCrate;
using DayaBay::Detector;
using DayaBay::ReadoutHeader;
using DayaBay::Readout;
using DayaBay::ReadoutPmtCrate;
using DayaBay::ReadoutRpcCrate;
using DybDaq::DaqFormatContext;
using DybDaq::DaqFormatConversionSvc;
using DybDaq::DaqEventConverter;
using DybDaq::EventHeader;
using DybDaq::EventReadout;
using DybDaq::EventTraits;
using DybDaq::LtbFrame;
using DybDaq::LtbReadout;
using DybDaq::LtbTime;
using DybDaq::RomData;
using DybDaq::RomFragment;
using DybDaq::RomHeader;

DaqEventConverter::Address::Address(const DaqFormatContext& context) :
    GenericAddress(storageType(),
                   classID()),
    m_context(context) {
}

DaqEventConverter::Address::~Address() {
}

const DaqFormatContext& DaqEventConverter::Address::context() const {
    return m_context;
}

DaqEventConverter::DaqEventConverter(unsigned char storageType,
                                     const CLID& clid,
                                     ISvcLocator* svc) :
    Converter(storageType,
              clid,
              svc) {
}

DaqEventConverter::DaqEventConverter(ISvcLocator* svc) :
    Converter(storageType(),
              classID(),
              svc) {
}

DaqEventConverter::~DaqEventConverter() {
}

const long DaqEventConverter::storageType() {
    return DaqFormatConversionSvc::DAQ_FORMAT_DATA;
}

const CLID& DaqEventConverter::classID() {
    return DayaBay::CLID_ReadoutHeader;
}

StatusCode DaqEventConverter::createObj(IOpaqueAddress* addr,
                                        DataObject*& pObject) {
    Address* address = dynamic_cast<Address*>(addr);
    if (0 == address) {
        return StatusCode::FAILURE;
    }
    const EventReadout* eventReadout = address->context().event();
    if (0 == eventReadout) {
        return StatusCode::FAILURE;
    }
    pObject = createReadoutHeader(*eventReadout);
    if (0 == pObject) {
        return StatusCode::FAILURE;
    }
    return StatusCode::SUCCESS;
    
}

ReadoutHeader* DaqEventConverter::createReadoutHeader(const EventReadout& event) {

    const EventHeader& header = event.header();
    const EventTraits& traits = header.eventTraits();
    const unsigned int kFeeModuleType = traits.moduleType(EventTraits::kFeeModule);
    const unsigned int kRpcRomModuleType = traits.moduleType(EventTraits::kRpcRomModule);

    const EventReadout::RomFragmentPtrList& fragments = event.romFragments();
    EventReadout::RomFragmentPtrList::const_iterator fragment = fragments.begin();
    const unsigned int* crateType = 0;
    while(0 == crateType && fragment != fragments.end()) {
        if (kFeeModuleType == ((*fragment)->header().moduleType())) {
            crateType = &kFeeModuleType;
        }
        else if ( kRpcRomModuleType == ((*fragment)->header().moduleType())) {
           crateType = &kRpcRomModuleType;
        }
        ++fragment;
    }
    if (0 == crateType) {
        return 0;
    }

    if ((*crateType) == kFeeModuleType) {
        const DaqPmtCrate* pmtCrate = new DaqPmtCrate(&event);
        const Detector& detector = pmtCrate->detector();
        const TimeStamp& triggerTime = pmtCrate->triggerTime();
        Context context(detector.site(),
                        SimFlag::kData,
                        triggerTime,
                        detector.detectorId());
        ReadoutHeader* result = new ReadoutHeader();
        result->setContext(context);
        result->setEarliest(triggerTime);
        result->setLatest(triggerTime);
        
        // Add the readout to the header
        result->setDaqCrate(const_cast<DaqPmtCrate*>(pmtCrate));
        
        return result;
    }
    else if ((*crateType) == kRpcRomModuleType) {
       // FIXME : to set the Context of ReadoutHeader
       ReadoutHeader* result = new ReadoutHeader();
       Readout*  readout = new Readout();
       readout->setEventReadout(const_cast<EventReadout*>(&event));
       result->setReadout(readout);
       return result;
    }

    MsgStream log(msgSvc(),
                  "DaqEventConverter");
    log << MSG::ERROR << "Could not determine crate type so, cannot make readout." << endreq;
    return 0;
}

long DaqEventConverter::repSvcType() const {
    return i_repSvcType();
}

---