ROsFecReadoutTool.cc

Go to the documentation of this file.

#include "ROsFecReadoutTool.h"

#include "Conventions/Detectors.h"
#include "Conventions/Trigger.h"
#include "Conventions/Site.h"
#include "Conventions/Electronics.h"

#include "Event/SimReadoutHeader.h"
#include "Event/ReadoutTriggerDataPkg.h"

#include "Event/ElecCrateHeader.h"
#include "Event/ElecFecCrate.h"

#include "Event/SimTrigCommand.h"
#include "Event/SimTrigCommandHeader.h"
#include "Event/SimTrigCommandCollection.h"

ROsFecReadoutTool::ROsFecReadoutTool(const std::string& type,
                               const std::string& name,
                               const IInterface* parent)
    : GaudiTool(type,name,parent)
{
  declareInterface< IROsReadoutTool >(this) ;
  // for now add all but RPC's as default.
  m_detectorsToProcess.push_back("DayaBayRPC");
  m_detectorsToProcess.push_back("LingAoRPC");
  m_detectorsToProcess.push_back("FarRPC");

  declareProperty("detectorsToProcess",m_detectorsToProcess,
                  "List of detectors to process with this tool");
  declareProperty("refuseTime",m_refuseTime = 8,
                  "Time in clk cycles for which FEC will refuse readout");
  declareProperty("readoutWindow",m_readoutWindow = 16,
                  "Number of clk cycles to OR the signal in each channel when reading out.");
  declareProperty("readoutWindowPosition",m_readoutWindowPosition = 8,
                  "Number of clk cycles to OR the signal in each channel when reading out.");
}

ROsFecReadoutTool::~ROsFecReadoutTool(){}

StatusCode ROsFecReadoutTool::initialize()
{
    std::vector<std::string>::iterator it;
    for(it=m_detectorsToProcess.begin();it!=m_detectorsToProcess.end();++it){
        short int detId = DayaBay::Detector::siteDetPackedFromString(*it);
        DayaBay::Detector det(detId);
        m_detectors.insert(det);
    }

    return StatusCode::SUCCESS;
}

StatusCode ROsFecReadoutTool::finalize()
{
  return StatusCode::SUCCESS;
}

StatusCode ROsFecReadoutTool::makeReadouts(DayaBay::SimReadoutHeader* roHeader,
                                           std::vector<DayaBay::ReadoutTriggerDataPkg*>& trigDataPkg,
                                           const DayaBay::ElecHeader& elecHeader)
{
    debug() << "running makeReadouts() in ROsFecReadoutTool" << endreq;

    DayaBay::SimReadoutHeader::SimReadoutContainer& outputReadouts
        = roHeader->readouts();

    Context context = roHeader->context();
    //Get Crate Map
    const DayaBay::ElecCrateHeader *ech = elecHeader.crateHeader();
    const DayaBay::ElecCrateHeader::CrateMap crMap = ech->crates();
    DayaBay::ElecCrateHeader::CrateMap::const_iterator crIt;

    std::vector<DayaBay::ReadoutTriggerDataPkg*>::iterator pkgIt;

    //Loop over All trigger data packages
    for(pkgIt = trigDataPkg.begin(); pkgIt != trigDataPkg.end(); ++pkgIt) {
        DayaBay::Detector det((*pkgIt)->detector());
        if(m_detectors.find(det) != m_detectors.end()){
            if((*pkgIt)->frames().size()==0){
                fatal() << "makeReadouts(): Trying to process a trigger for " << det.detName()
                    << " But Package Has No Frames" << endreq;
                return StatusCode::FAILURE;
            }

            crIt = crMap.find(det);
            const DayaBay::ElecFecCrate *crate;
            if(crIt == crMap.end()){
                fatal() << "makeReadouts(): Trying to process a trigger for " << det.detName()
                    << " But no crate exists." << endreq;
                return StatusCode::FAILURE;
            } else {
                crate = dynamic_cast<const DayaBay::ElecFecCrate*>(crIt->second);
                if (!crate) { // is not fec crate?
                    fatal() << "makeReadouts(): We are supposed to process FEC crate, but did not get it."
                        << endreq;
                    return StatusCode::FAILURE;
                }
                debug() << "makeReadouts(): Processing a trigger for " << det.detName()
                    << " found crate at " << crate << endreq;
            }

            if(crate != 0){ // if the crate exists read it out.
                debug()<<"Reading out 1 trigger with: "
                    <<((*pkgIt)->frames().size())-1
                    <<" masked triggers."<<endreq;
                if (msgLevel(MSG::VERBOSE)) { // Print out list of boards in the ElecCrate
                  verbose()<<"makeReadouts(): ElecFecCrate: {"<<crate->detector()<<", boards: {";
                  DayaBay::ElecFecCrate::FecBoardMap::const_iterator brdIt, brdDone = crate->fecBoards().end();
                  for (brdIt = crate->fecBoards().begin(); brdIt != brdDone; brdIt++) {
                    verbose()<<brdIt->first<<", ";
                  }
                  verbose()<<'\x08'<<'\x08'<<"}"<<endreq;
                }

                const DayaBay::ReadoutRpcTriggerDataFrame *tdf = (*pkgIt)->frames().at(0)->asRpcFrame();

                DayaBay::ReadoutRpcCrate *cr = readoutCrate(tdf,crate,context);
                if (!cr) { // could not create readout crate
                    error()<<"makeReadouts(): Cannot create readout crate."<<endreq;
                    return StatusCode::FAILURE;
                }
                outputReadouts.push_back(new DayaBay::SimReadout(cr,
                    roHeader));

                (*pkgIt)->setReadout(cr);
                cr->setTriggerDataPkg(*pkgIt);
                if (msgLevel(MSG::VERBOSE)) {
                    verbose() << "makeReadouts(): Set readout's trigger data package:\n" << (**pkgIt) << endreq;
                }
            }
        }else{
            if (msgLevel(MSG::VERBOSE)) {
                verbose() << "Found Trigger For " << det.detName()
                        << "but this tool is not supposed "
                        << "to process that detector type "
                        << "check properties to configure."
                        << endreq;
            }
        }
    }

    if (msgLevel(MSG::VERBOSE)) {
        verbose() << "makeReadouts(): ReadoutHeader: " << (*roHeader) <<endreq;
    }

  return StatusCode::SUCCESS;
}

// provide mutate to satisfy interface IROsReadoutTool.
StatusCode ROsFecReadoutTool::mutate(DayaBay::SimReadoutHeader* roHeader,
                                     std::vector<DayaBay::ReadoutTriggerDataPkg*>& trigDataPkg,
                                     const DayaBay::ElecHeader& elecHeader)
{
    debug() << "mutate(): start mutating the ReadoutHeader" << endreq;
    StatusCode sc = makeReadouts(roHeader, trigDataPkg, elecHeader);
    if (sc.isFailure()) {
        return StatusCode::FAILURE;
    } else
        return StatusCode::SUCCESS;
}

DayaBay::ReadoutRpcCrate* ROsFecReadoutTool::readoutCrate(const DayaBay::ReadoutRpcTriggerDataFrame *tdf,
                                                          const DayaBay::ElecFecCrate *cr, Context context)
{
    TimeStamp triggerTime(tdf->triggerTime());

    DayaBay::ReadoutRpcCrate *out_readout
            = new DayaBay::ReadoutRpcCrate(cr->detector(),0, triggerTime, tdf->triggerType());
    DayaBay::ReadoutRpcCrate::FecReadouts ro_brdMap;

    const DayaBay::ElecFecCrate::FecBoardMap& brdMap = cr->fecBoards();
    const std::map< DayaBay::FecChannelId, DayaBay::Trigger::TriggerType_t >
                    &trigBoards = tdf->outTriggers();
    std::map< DayaBay::FecChannelId, DayaBay::Trigger::TriggerType_t >::const_iterator brdIt;

    debug()<<"readoutCrate(): Start looping over "<<trigBoards.size()<<" boards in triggered boards."<<endreq;
    for(brdIt = trigBoards.begin(); brdIt != trigBoards.end() ; ++brdIt){
        DayaBay::FecChannelId brdId = brdIt->first;
        DayaBay::ElecFecCrate::FecBoardMap::const_iterator elecBrdIt = brdMap.find(brdId);
        if (elecBrdIt == brdMap.end()) { // did not find the board in the elec crate
          error()<<"readoutCrate(): triggered board, "<<brdId<<"/"<<brdIt->first<<", is not in the current elec crate."<<endreq;
            return 0;
        }
        DayaBay::ReadoutFecBoard *ro_brd = readoutBoard(tdf, &(elecBrdIt->second), context);

        if (ro_brd == 0) continue;         // test to see if channel has readout
        ro_brd->setReadout(out_readout);
        ro_brdMap[brdId] = *ro_brd;   // copy the value by it's address to the map
        ro_brd->setReadout(0);             // reset Readout, to avoid double deletion
        delete ro_brd;                     // delete unnecessary copy
    }

    out_readout->setFecReadouts(ro_brdMap);
    return out_readout;
}

DayaBay::ReadoutFecBoard* ROsFecReadoutTool::readoutBoard(
                    const DayaBay::ReadoutRpcTriggerDataFrame *tdf,
                    const DayaBay::ElecFecBoard *brd,
                    Context context)
{
    int cycle = tdf->cycle();
    TimeStamp trigTime = tdf->triggerTime();
    // FIXME: check if the trigTime and clock cycle correspond to the simulated window in elec sim.
    const DayaBay::ElecFecBoard::ChannelMap& channels = brd->channels();
    DayaBay::ReadoutFecBoard::FecHitmap hm = 0;
    DayaBay::FecChannelId brdId = brd->boardId();

    std::map<DayaBay::ElecChannelId, TimeStamp>::iterator muteIt = m_lastRead.find(brdId);
    if (muteIt != m_lastRead.end()) {
        // triggers should be time ordered, so it should never happen
        // that current trigger time would be further in past compared to the last readout
        TimeStamp lastRoT = muteIt->second;
        lastRoT.Add((double) m_refuseTime / (double) DayaBay::BaseFrequencyHz);
        if (lastRoT > trigTime) { // FEC still muted
            return 0;
        }
    }

    // loop over channels of this board
    DayaBay::ElecFecBoard::ChannelMap::const_iterator chIt, chDone = channels.end();
    debug()<<"readoutBoard(): Start looping over "<<channels.size()<<" channels in elec board "<<brdId<<endreq;
    for ( chIt = channels.begin(); chIt != chDone; chIt++) {
        // FIXME: check where the cycle is with respect to the simulation window/mainly beginning
        //  put into higher level!

        const DayaBay::DigitalSignal& hits = chIt->second.hits();
        if (msgLevel(MSG::VERBOSE)) {
          verbose()<<"Prepare to start looping over "<<hits.size()<<" cycles in the "
                 <<chIt->first<<" channel's digital signal"<<endreq;
        }
        // loop over clock cycles in the board and prepare hitmap;
        // only in specified readout window
        DayaBay::DigitalSignal::const_iterator hitIt, hitDone = hits.end();
        int iteration = 0;
        hitIt = hits.begin();
        //unsigned int setbit = 0x1<<(chIt->first.connector()); // Convention: connector starts at 0
        unsigned int setbit = chIt->first.fecHit();
        if ( cycle - m_readoutWindowPosition > 0 ) {
            hitIt = hitIt + cycle - m_readoutWindowPosition;
        }
        for ( ;
              hitIt < hitDone && iteration <= m_readoutWindow;
              hitIt++, iteration++) {
            if (*hitIt) {
                hm |= setbit; // fill into the hit map
                break;
            }
        }
        if (hitIt == hitDone && iteration < m_readoutWindow) { // trigger issued very close to the end of sim window
            // FIXME: Put this to the top level - before dealing with boards!
            //  deal with short simulation window; warning is enough?
        }
    }
    if (msgLevel(MSG::VERBOSE)) {
        verbose()<<"ReadoutBoard(): board: "<<brdId<<", hitmap = 0x"<<std::hex << hm << std::dec<<endreq;
    }

    // the FEC is not muted, let's create its readout
    DayaBay::ReadoutFecBoard *ro_brd = new DayaBay::ReadoutFecBoard(brd->boardId(),0);
    // check if it is in input triggers and what flag it is given
    // FIXME: do it properly, based on the data in readout window, the trigger flags may have changed
    std::map< DayaBay::FecChannelId,DayaBay::Trigger::TriggerType_t >::const_iterator
        inTrigIt = tdf->inTriggers().find(brdId);
    if ( inTrigIt != tdf->inTriggers().end() ) { // the boared has local trigger
        if (inTrigIt->second == DayaBay::Trigger::kRPC3of4) { // the trigger is 3 of 4
            ro_brd->setFlag3of4(true);
        }
        ro_brd->setFlag2of4(true);
    }
    // fill the hitmap
    ro_brd->setHitMap(hm);

    // Save last readout time
    m_lastRead[brdId] = trigTime;

    return ro_brd;
}