In This Package:

FecReadout.cc

Go to the documentation of this file.

#include "FecReadoutFormat/FecReadout.h"
#include "FecReadoutFormat/FecTraits.h"
#include "FecReadoutFormat/FecData.h"
#include "DaqReadoutFormat/ByteBuffer.h"

#include <iostream>

using DybDaq::DaqTraits;
using DybDaq::FecData;
using DybDaq::FecTraits;
using DybDaq::FecReadout;


FecReadout::FecReadout(const FecTraits& traits)
   : DaqContainer(),
     m_fecList(0),
     m_verFormat(0),
     m_fecTraits(&traits)
{
}

FecReadout::FecReadout(const ByteBuffer& byteBuffer,
                       const unsigned int bufferSize,
                       const unsigned int verFormat)
   : DaqContainer(byteBuffer, bufferSize),
     m_fecList(0),
     m_verFormat(verFormat),
     m_fecTraits(0)
{
   byteBuffer.position( byteBuffer.position() + bufferSize * kBytesInInt );
}

FecReadout::~FecReadout()
{
   if ( m_fecList != 0 ) {
      FecDataPtrList::iterator it = m_fecList->begin();
      while ( it != m_fecList->end() ) {
         delete *it;
         ++it;
      }
      delete m_fecList;
   }
}

const DaqTraits& FecReadout::daqTraits() const
{
   return fecTraits();
}

const FecReadout::FecDataPtrList& FecReadout::fecDataList() const
{
   if ( m_fecList == 0 ) {
      m_fecList = new FecDataPtrList();
      if ( hasByteBuffer() ) {
         const FecTraits& traits = fecTraits();
         const ByteBuffer& buffer = byteBuffer();

         const unsigned int originalPosition = buffer.position();
         buffer.position( begin() );
         const unsigned int finished = containerSize() / traits.fecSize();
         for ( unsigned int count = 0; count != finished; ++count ) {
            FecData* fecData = new FecData(buffer, traits);
            m_fecList->push_back(fecData);
         }
         buffer.position( originalPosition );
      }
   }
   return *m_fecList;
}

unsigned int FecReadout::romSize() const
{
   return bufferSize();
}

unsigned int FecReadout::gatherRom(OutputBufferList& outputBuffers) const
{
   return gather(outputBuffers);
}

unsigned int FecReadout::inspectRom(DaqBuffer::Bytes& inspectors) const
{
    return inspect(inspectors);
}

unsigned int FecReadout::bufferSize() const
{
   unsigned int result = 0;
   const FecDataPtrList& fecList = fecDataList();

   FecDataPtrList::const_iterator it = fecList.begin();
   while ( it != fecList.end() ) {
      result += (*it)->bufferSize();
      ++it;
   }

   return result;
}

const FecData& FecReadout::addFecData(const unsigned int rpcCFId,
                                      const unsigned int rpcFecId,
                                      const bool transErr1,
                                      const bool transErr2,
                                      const unsigned int trigType,
                                      const bool fullFlag,
                                      const bool validGPS,
                                      const bool validCLK,
                                      const bool usingUTC,
                                      const unsigned int second,
                                      const unsigned int nanoSecond,
                                      const unsigned int hitMap)
{
   FecData* result = new FecData(rpcCFId,
                                 rpcFecId,
                                 transErr1,
                                 transErr2,
                                 trigType,
                                 fullFlag,
                                 validGPS,
                                 validCLK,
                                 usingUTC,
                                 second,
                                 nanoSecond,
                                 hitMap,
                                 fecTraits() );
   return add( result );
}

unsigned int FecReadout::gatherComponents(OutputBufferList& outputBuffers) const 
{
   unsigned int result = 0;
   const FecDataPtrList& fecList = fecDataList();

   FecDataPtrList::const_iterator it = fecList.begin();
   while ( it != fecList.end() ) {
      result += (*it)->gather(outputBuffers);
      ++it;
   }

   return result;
}

unsigned int FecReadout::inspectComponents(DaqBuffer::Bytes& inspectors) const
{
    unsigned int result = 0;
    const FecDataPtrList& fecList = fecDataList();
    
    FecDataPtrList::const_iterator it = fecList.begin();
    while ( it != fecList.end() ) {
        result += (*it)->inspect(inspectors);
        ++it;
    }
    
    return result;
}

void FecReadout::expanded(const unsigned int size)
{
   notifyExpandable(size);
}

bool FecReadout::setRomExpandable(DaqExpandable& expandable)
{
   return setExpandable(expandable);
}

const FecTraits& FecReadout::fecTraits() const
{
   if ( m_fecTraits == 0 ) {
      m_fecTraits = FecTraits::getTraits(m_verFormat);
   }
   return *m_fecTraits;
}

const FecData& FecReadout::add(const FecData* fecData)
{
   if ( m_fecList == 0 ) {
      m_fecList = new FecDataPtrList();
   }

   m_fecList->push_back(fecData);
   expanded( fecData->bufferSize() );

   return *fecData;
}

---