l1t::demo::BoardDataReader Class Reference

#include <BoardDataReader.h>

Public Types
typedef std::map< LinkId, std::pair< ChannelSpec, std::vector< size_t > > >	ChannelMap_t

Public Member Functions
	BoardDataReader (FileFormat, const std::vector< std::string > &, const size_t framesPerBX, const size_t tmux, const size_t emptyFramesAtStart, const ChannelMap_t &)
	BoardDataReader (FileFormat, const std::vector< std::string > &, const size_t framesPerBX, const size_t tmux, const size_t emptyFramesAtStart, const std::map< LinkId, std::vector< size_t >> &, const std::map< std::string, ChannelSpec > &)
EventData	getNextEvent ()

Static Private Member Functions
static ChannelMap_t	mergeMaps (const std::map< LinkId, std::vector< size_t >> &, const std::map< std::string, ChannelSpec > &)

Private Attributes
size_t	boardTMUX_
ChannelMap_t	channelMap_
size_t	emptyFramesAtStart_
std::vector< EventData >::const_iterator	eventIt_
std::vector< EventData >	events_
FileFormat	fileFormat_
std::vector< std::string >	fileNames_
size_t	framesPerBX_

Detailed Description

Definition at line 21 of file BoardDataReader.h.

Member Typedef Documentation

ChannelMap_t

typedef std::map<LinkId, std::pair<ChannelSpec, std::vector<size_t> > > l1t::demo::BoardDataReader::ChannelMap_t

Definition at line 24 of file BoardDataReader.h.

Constructor & Destructor Documentation

BoardDataReader() [1/2]

l1t::demo::BoardDataReader::BoardDataReader	(	FileFormat	format,
		const std::vector< std::string > &	fileNames,
		const size_t	framesPerBX,
		const size_t	tmux,
		const size_t	emptyFramesAtStart,
		const ChannelMap_t &	channelMap
	)

Definition at line 10 of file BoardDataReader.cc.

References l1t::demo::EventData::add(), l1t::demo::BoardData::at(), boardTMUX_, channelMap_, emptyFramesAtStart_, eventIt_, events_, fileFormat_, fileNames_, framesPerBX_, l1t::demo::BoardData::has(), mps_fire::i, dqmdumpme::indices, l1ctLayer2EG_cff::interface, dqmiolumiharvest::j, castor_dqm_sourceclient_file_cfg::path, l1t::demo::read(), to_string(), and relativeConstraints::value.

      : fileFormat_(format),
        fileNames_(fileNames),
        framesPerBX_(framesPerBX),
        boardTMUX_(tmux),
        emptyFramesAtStart_(emptyFramesAtStart),
        channelMap_(channelMap),
        events_() {
    // TODO (long term): Move much of this to separate function, and only read files on demand

    // Verify that channel map/spec is self-consistent
    for (const auto& [id, value] : channelMap_) {
      const auto& [spec, indices] = value;
      if ((spec.tmux % boardTMUX_) != 0)
        throw std::runtime_error("Link [" + id.interface + ", " + std::to_string(id.channel) +
                                 "]: Specified TMUX period, " + std::to_string(spec.tmux) +
                                 ", is not a multiple of the board TMUX, " + std::to_string(boardTMUX_));

      const size_t tmuxRatio(spec.tmux / boardTMUX_);
      if (indices.size() != tmuxRatio)
        throw std::runtime_error("Link [" + id.interface + ", " + std::to_string(id.channel) +
                                 "]: Number of channel indices specified, " + std::to_string(indices.size()) +
                                 ", does not match link:board TMUX ratio");
    }

    // Loop over input files
    for (const auto& path : fileNames_) {
      BoardData boardData(read(path, fileFormat_));

      // 1) Verify that all expected channels are present
      for (const auto& [id, value] : channelMap_) {
        const auto& [spec, indices] = value;
        for (const auto i : indices) {
          if (not boardData.has(i))
            throw std::runtime_error("Channel " + std::to_string(i) + " was declared but is missing from file '" +
                                     path + "'");
        }
      }

      // 2) Verify that packet structure is as expected
      for (const auto& [id, value] : channelMap) {
        const auto& [spec, indices] = value;
        for (size_t tmuxIndex = 0; tmuxIndex < indices.size(); tmuxIndex++) {
          const auto& chanData = boardData.at(indices.at(tmuxIndex));

          const size_t framesBeforeFirstPacket(emptyFramesAtStart_ + tmuxIndex * boardTMUX_ * framesPerBX_ +
                                               spec.offset);
          const size_t eventLength(spec.tmux * framesPerBX_);
          const size_t packetLength(eventLength - spec.interpacketGap);

          for (size_t j = 0; j < framesBeforeFirstPacket; j++) {
            if (chanData.at(j).valid)
              throw std::runtime_error("Frame " + std::to_string(j) + " on channel " +
                                       std::to_string(indices.at(tmuxIndex)) + " is valid, but first " +
                                       std::to_string(framesBeforeFirstPacket) + "frames should be invalid");
          }

          for (size_t j = framesBeforeFirstPacket; j < chanData.size(); j++) {
            if ((j + (framesPerBX_ * spec.tmux)) >= chanData.size())
              continue;

            bool expectValid(((j - framesBeforeFirstPacket) % eventLength) < packetLength);

            if (expectValid) {
              if (not chanData.at(j).valid)
                throw std::runtime_error("Frame " + std::to_string(j) + " on channel " +
                                         std::to_string(indices.at(tmuxIndex)) +
                                         " is invalid, but expected valid frame");
            } else if (chanData.at(j).valid)
              throw std::runtime_error("Frame " + std::to_string(j) + " on channel " +
                                       std::to_string(indices.at(tmuxIndex)) + " is valid, but expected invalid frame");
          }
        }
      }

      // 3) Extract the data for each event
      bool eventIncomplete(false);
      for (size_t eventIndex = 0;; eventIndex++) {
        EventData eventData;

        for (const auto& [id, value] : channelMap) {
          const auto& [spec, indices] = value;
          const auto& chanData = boardData.at(indices.at(eventIndex % (spec.tmux / boardTMUX_)));

          // Extract the frames for this event
          const size_t framesBeforeEvent(eventIndex * boardTMUX_ * framesPerBX_ + emptyFramesAtStart_ + spec.offset);
          const size_t packetLength(spec.tmux * framesPerBX_ - spec.interpacketGap);

          if (chanData.size() < (framesBeforeEvent + spec.tmux * framesPerBX_)) {
            eventIncomplete = true;
            break;
          }

          std::vector<ap_uint<64>> chanEventData(packetLength);
          for (size_t j = 0; j < packetLength; j++)
            chanEventData.at(j) = chanData.at(framesBeforeEvent + j).data;
          eventData.add(id, chanEventData);
        }

        if (eventIncomplete)
          break;

        events_.push_back(eventData);
      }
    }

    eventIt_ = events_.begin();
  }

BoardDataReader() [2/2]

l1t::demo::BoardDataReader::BoardDataReader	(	FileFormat	format,
		const std::vector< std::string > &	fileNames,
		const size_t	framesPerBX,
		const size_t	tmux,
		const size_t	emptyFramesAtStart,
		const std::map< LinkId, std::vector< size_t >> &	channelMap,
		const std::map< std::string, ChannelSpec > &	channelSpecs
	)

Definition at line 124 of file BoardDataReader.cc.

      : BoardDataReader(format, fileNames, framesPerBX, tmux, emptyFramesAtStart, mergeMaps(channelMap, channelSpecs)) {
  }

Member Function Documentation

getNextEvent()

EventData l1t::demo::BoardDataReader::getNextEvent

(

)

Definition at line 134 of file BoardDataReader.cc.

References eventIt_, and events_.

Referenced by GTTFileReader::produce().

                                          {
    if (eventIt_ == events_.end())
      throw std::runtime_error("Board data reader ran out of events");

    return *(eventIt_++);
  }

mergeMaps()

BoardDataReader::ChannelMap_t l1t::demo::BoardDataReader::mergeMaps ( const std::map< LinkId, std::vector< size_t >> &  indexMap, const std::map< std::string, ChannelSpec > &  specMap  )

staticprivate

Definition at line 141 of file BoardDataReader.cc.

References x.

                                                                                                          {
    ChannelMap_t channelMap;
    for (const auto& x : indexMap)
      channelMap.at(x.first) = {specMap.at(x.first.interface), x.second};
    return channelMap;
  }

Member Data Documentation

boardTMUX_

size_t l1t::demo::BoardDataReader::boardTMUX_

private

Definition at line 53 of file BoardDataReader.h.

Referenced by BoardDataReader().

channelMap_

ChannelMap_t l1t::demo::BoardDataReader::channelMap_

private

Definition at line 58 of file BoardDataReader.h.

Referenced by BoardDataReader().

emptyFramesAtStart_

size_t l1t::demo::BoardDataReader::emptyFramesAtStart_

private

Definition at line 55 of file BoardDataReader.h.

Referenced by BoardDataReader().

eventIt_

std::vector<EventData>::const_iterator l1t::demo::BoardDataReader::eventIt_

private

Definition at line 62 of file BoardDataReader.h.

Referenced by BoardDataReader(), and getNextEvent().

events_

std::vector<EventData> l1t::demo::BoardDataReader::events_

private

Definition at line 60 of file BoardDataReader.h.

Referenced by BoardDataReader(), and getNextEvent().

fileFormat_

FileFormat l1t::demo::BoardDataReader::fileFormat_

private

Definition at line 47 of file BoardDataReader.h.

Referenced by BoardDataReader().

fileNames_

std::vector<std::string> l1t::demo::BoardDataReader::fileNames_

private

Definition at line 49 of file BoardDataReader.h.

Referenced by BoardDataReader().

framesPerBX_

size_t l1t::demo::BoardDataReader::framesPerBX_

private

Definition at line 51 of file BoardDataReader.h.

Referenced by BoardDataReader().