MatacqRawEvent.h

Go to the documentation of this file.

// -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: t; tab-width: 8; -*-

#ifndef MATACQTBRAWEVENT_H
#define MATACQTBRAWEVENT_H

#include <cinttypes>
#include <ctime>
#include <vector>
//replace 1 by 0 to remove XDAQ dependency. In this case it is assumed the machine is little endian.
#if 0
#include "i2o/utils/endian.h"  //from XDAQ
#define UINT32_FROM_LE i2odecodel
#define UINT16_FROM_LE i2odecodes
#define INT16_FROM_LE i2odecodes

#else  //assuming little endianness of the machine

#define UINT32_FROM_LE
#define UINT16_FROM_LE
#define INT16_FROM_LE

#endif

class MatacqTBRawEvent {
  //typedefs, enums and static constants
public:
  enum matacqError_t {
    errorLengthConsistency = 1 << 0,
    errorLength = 1 << 1,
    errorWrongBoe = 1 << 2
  };

  /* The following types are little-endian encoded types. Use of these types
   * for the I20 data block should offer portability to big-endian platforms.
   */
  struct uint32le_t {
    uint32_t littleEndianInt;
    operator uint32_t() const { return UINT32_FROM_LE(littleEndianInt); }
  };

  struct uint16le_t {
    uint16_t littleEndianInt;
    operator uint16_t() const { return UINT16_FROM_LE(littleEndianInt); }
  };

  struct int16le_t {
    int16_t littleEndianInt;
    operator int16_t() const { return INT16_FROM_LE(littleEndianInt); }
  };

  struct ChannelData {
    int chId;
    int nSamples;
    const int16le_t* samples;
  };

private:
  struct matacqHeader_t {
    uint16le_t version;
    unsigned char freqGHz;
    unsigned char channelCount;
    uint32_t timeStamp;
  };

  struct field32spec_t {
    int offset;
    unsigned int mask;
  };

  static const field32spec_t fov32;
  static const field32spec_t fedId32;
  static const field32spec_t bxId32;
  static const field32spec_t lv132;
  static const field32spec_t triggerType32;
  static const field32spec_t boeType32;
  static const field32spec_t dccLen32;
  static const field32spec_t dccErrors32;
  static const field32spec_t runNum32;
  static const field32spec_t h1Marker32;

  //constructors
public:
  MatacqTBRawEvent(const unsigned char* dataBuffer, std::size_t bufferSize) { setRawData(dataBuffer, bufferSize); }
  //methods
public:
  int getFov() const { return read32(daqHeader, fov32); }

  int getFedId() const { return read32(daqHeader, fedId32); }

  int getBxId() const { return read32(daqHeader, bxId32); }

  unsigned getEventId() const { return read32(daqHeader, lv132); }

  int getTriggerType() const { return read32(daqHeader, triggerType32); }

  int getBoe() const { return read32(daqHeader, boeType32); }

  unsigned getDccLen() const { return read32(daqHeader, dccLen32); }

  unsigned getDaqLen() const { return fragLen; }

  int getDccErrors() const { return read32(daqHeader, dccErrors32); }

  unsigned getRunNum() const { return read32(daqHeader, runNum32); }

  int getH1Marker() const { return read32(daqHeader, h1Marker32); }

  int getMatacqDataFormatVersion() const { return matacqHeader->version; }

  int32_t getStatus() const { return error; }

  int getFreqGHz() const { return matacqHeader->freqGHz; }

  int getChannelCount() const { return matacqHeader->channelCount; }

  const std::vector<ChannelData>& getChannelData() const { return channelData; }

  int getParsedLen() { return parsedLen; }

  time_t getTimeStamp() const { return matacqHeader->timeStamp; }

  int getTTrigPs() const { return tTrigPs; }

private:
  int read32(const uint32le_t* pData, field32spec_t spec) const;

  void setRawData(const unsigned char* buffer, std::size_t bufferSize);

  //fields
private:
  int boe;

  int bxId;

  int channelCount;

  std::vector<ChannelData> channelData;

  const uint32le_t* daqHeader;

  int dccErrors;

  unsigned dccLen;

  unsigned eventId;

  int32_t error;

  int fedId;

  int fov;

  int fragLen;

  int freqGHz;

  int h1Marker;

  const matacqHeader_t* matacqHeader;

  int matacqDataFormatVersion;

  int parsedLen;

  uint16le_t* pSamples;

  unsigned runNum;

  time_t timeStamp;

  int tTrigPs;

  int triggerType;
};

#endif  //MATACQRAWEVENT_H not defined