MatacqRawEvent.h

Go to the documentation of this file.

// -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: t; tab-width: 8; -*-
 
#ifndef MATACQRAWEVENT_H
#define MATACQRAWEVENT_H
 
#include <cinttypes>
#include <cstddef>
#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
 
#include <sys/time.h>  //for timeval definition
 
class MatacqRawEvent {
  //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{
  //     uint16_t version;
  //     unsigned char freqGHz;
  //     unsigned char channelCount;
  //     uint32_t orbitId;
  //     unsigned char trigRec;
  //     uint16_t postTrig;
  //     uint16_t vernier[4];
  //     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;
 
 
  static const field32spec_t formatVersion32;
  static const field32spec_t freqGHz32;
  static const field32spec_t channelCount32;
  static const field32spec_t timeStamp32;
  static const field32spec_t tTrigPs32;
  static const field32spec_t orbitId32;
  static const field32spec_t trigRec32;
  static const field32spec_t postTrig32;
  static const field32spec_t vernier0_32;
  static const field32spec_t vernier1_32;
  static const field32spec_t vernier2_32;
  static const field32spec_t vernier3_32;
  static const field32spec_t timeStampMicroSec32;
 
  static const field32spec_t laserPower32;
  static const field32spec_t attenuation_dB32;
  static const field32spec_t emtcPhase32;
  static const field32spec_t emtcDelay32;
  static const field32spec_t delayA32;
  static const field32spec_t dccId32;
  static const field32spec_t color32;
  static const field32spec_t trigType32;
  static const field32spec_t side32;
 
 
  //constructors
public:
  MatacqRawEvent(const unsigned char* dataBuffer, size_t bufferSize) : vernier(std::vector<int>(4)) {
    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); }
 
  static unsigned getDccLen(unsigned char* data, size_t size) {
    if (size < (unsigned)(dccLen32.offset + 1) * 4)
      return (unsigned)-1;
    return read32((uint32le_t*)data, dccLen32);
  }
 
  static unsigned getOrbitId(unsigned char* data, size_t size) {
    if (size < (unsigned)(orbitId32.offset + 1) * 8)
      return (unsigned)-1;
    return read32((uint32le_t*)data, orbitId32);
  }
 
  static unsigned getRunNum(unsigned char* data, size_t size) {
    if (size < (unsigned)(runNum32.offset + 1) * 8)
      return (unsigned)-1;
    return read32((uint32le_t*)data, runNum32);
  }
 
  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 matacqDataFormatVersion; }
 
  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.tv_sec; }
 
  void getTimeStamp(struct timeval& t) const { t = timeStamp; }
 
  int getTTrigPs() const { return tTrigPs; }
 
  uint32_t getOrbitId() const { return orbitId; }
 
  int getTrigRec() const { return trigRec; }
 
  int getPostTrig() const { return postTrig; }
 
  std::vector<int> getVernier() const { return vernier; }
 
  int getDelayA() const { return delayA; }
 
  int getEmtcDelay() const { return emtcDelay; }
 
  int getEmtcPhase() const { return emtcPhase; }
 
  int getAttenuation_dB() const { return attenuation_dB; }
 
  int getLaserPower() const { return laserPower; }
 
private:
  static int read32(const uint32le_t* pData, field32spec_t spec, bool ovfTrans = false);
 
  //   /** Help function to get the maximum value of a data field
  //    * @param spec32 data field specification
  //    * @return maximum value
  //    */
  //   int max32(field32spec_t spec32) const;
 
  void setRawData(const unsigned char* buffer, 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;
 
  //  matacqHeader_t* matacqHeader;
 
  int matacqDataFormatVersion;
 
  int parsedLen;
 
  uint16le_t* pSamples;
 
  unsigned runNum;
 
  struct timeval timeStamp;
 
  int tTrigPs;
 
  int triggerType;
 
  /* LHC orbit ID
   */
  uint32_t orbitId;
 
  int trigRec;
 
  int postTrig;
 
  std::vector<int> vernier;
 
  int delayA;
 
  int emtcDelay;
 
  int emtcPhase;
 
  int attenuation_dB;
 
  int laserPower;
};
 
#endif  //MATACQRAWEVENT_H not defined