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 <inttypes.h>
#include <vector>

#if 0 //replace 1 by 0 to remove XDAQ dependency. In this case it is assumed the
      //machine is little endian.
#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