#include <MatacqRawEvent.h>

Classes
struct	ChannelData
struct	field32spec_t
struct	int16le_t
struct	matacqHeader_t
struct	uint16le_t
struct	uint32le_t
Public Types
enum	matacqError_t { errorLengthConsistency = 1<<0, errorLength = 1<<1, errorWrongBoe = 1<<2 }
Public Member Functions
int	getBoe () const
int	getBxId () const
int	getChannelCount () const
const std::vector< ChannelData > &	getChannelData () const
unsigned	getDaqLen () const
int	getDccErrors () const
unsigned	getDccLen () const
unsigned	getEventId () const
int	getFedId () const
int	getFov () const
int	getFreqGHz () const
int	getH1Marker () const
int	getMatacqDataFormatVersion () const
int	getParsedLen ()
unsigned	getRunNum () const
int32_t	getStatus () const
time_t	getTimeStamp () const
int	getTriggerType () const
int	getTTrigPs () const
	MatacqTBRawEvent (const unsigned char *dataBuffer, size_t bufferSize)
Private Member Functions
int	read32 (uint32le_t *pData, field32spec_t spec) const
void	setRawData (const unsigned char *buffer, size_t bufferSize)
Private Attributes
int	boe
int	bxId
int	channelCount
std::vector< ChannelData >	channelData
uint32le_t *	daqHeader
int	dccErrors
unsigned	dccLen
int32_t	error
unsigned	eventId
int	fedId
int	fov
int	fragLen
int	freqGHz
int	h1Marker
int	matacqDataFormatVersion
matacqHeader_t *	matacqHeader
int	parsedLen
uint16le_t *	pSamples
unsigned	runNum
time_t	timeStamp
int	triggerType
int	tTrigPs
Static Private Attributes
static const field32spec_t	boeType32 = {1, 0xF0000000}
static const field32spec_t	bxId32 = {0, 0xFFF00000}
static const field32spec_t	dccErrors32 = {2, 0xFF000000}
static const field32spec_t	dccLen32 = {2, 0x00FFFFFF}
static const field32spec_t	fedId32 = {0, 0x000FFF00}
static const field32spec_t	fov32 = {0, 0x000000F0}
static const field32spec_t	h1Marker32 = {3, 0xF0000000}
static const field32spec_t	lv132 = {1, 0x00FFFFFF}
static const field32spec_t	runNum32 = {3, 0x00FFFFFF}
static const field32spec_t	triggerType32 = {1, 0x0F000000}

Detailed Description

Wrapper for matacq raw event fragments. This class provides the method to interpret the data.

Definition at line 27 of file MatacqRawEvent.h.

Member Enumeration Documentation

enum MatacqTBRawEvent::matacqError_t

Enumerator:

errorLengthConsistency	Event length is specified both in the data header and the trailer. This flags indicates an inconsitency between the two indications.
errorLength	Error in data length.
errorWrongBoe	Wrong Begin of eevent flag

Definition at line 30 of file MatacqRawEvent.h.

                     {
    errorLengthConsistency = 1<<0,
    errorLength = 1<<1,
    errorWrongBoe = 1<<2
  };

Constructor & Destructor Documentation

MatacqTBRawEvent::MatacqTBRawEvent	(	const unsigned char *	dataBuffer,
		size_t	bufferSize
	)		`[inline]`

Constuctor.

Parameters:

dataBuffer	pointer to the raw data. Beware the data are not copied, therefore the data must be kept valid during the lifetime of the constructed object. pData must be aligned at least on 32-bit words.
bufferSize	size of the buffer pointed by dataBuffer and containing the data. The data themselves are allowed to be smaller than the buffer.

Exceptions:

std::exception if the data cannot be decoded due to data corruption or truncation.

Definition at line 123 of file MatacqRawEvent.h.

References setRawData().

                                                                      {
    setRawData(dataBuffer, bufferSize);
  }

Member Function Documentation

int MatacqTBRawEvent::getBoe ( ) const [inline]

Gets the beging of event field contents (BOE). Must be 0x5.

Returns:: BOE

Definition at line 159 of file MatacqRawEvent.h.

References boeType32, daqHeader, and read32().

Referenced by setRawData().

{ return read32(daqHeader, boeType32);}

int MatacqTBRawEvent::getBxId ( ) const [inline]

Gets the bunch crossing id field contents.

Returns:: BX id

Definition at line 144 of file MatacqRawEvent.h.

References bxId32, daqHeader, and read32().

{ return read32(daqHeader, bxId32);}

int MatacqTBRawEvent::getChannelCount ( ) const [inline]

Gets the matacq channel count field contents.

Returns:: number of channels

Definition at line 207 of file MatacqRawEvent.h.

References MatacqTBRawEvent::matacqHeader_t::channelCount, and matacqHeader.

Referenced by setRawData().

{ return matacqHeader->channelCount;}

const std::vector<ChannelData>& MatacqTBRawEvent::getChannelData ( ) const [inline]

Gets the matacq channel data. Beware that no copy is done and that the returned data will be invalidated if the data contains in the buffer is modified (see constructor and setRawData().

Returns:: matacq channel data.

Definition at line 214 of file MatacqRawEvent.h.

References channelData.

                                                      {
    return channelData;
  }

unsigned MatacqTBRawEvent::getDaqLen ( ) const [inline]

Gets the event length specifies in the DAQ trailer

Returns:: event length

Definition at line 169 of file MatacqRawEvent.h.

References fragLen.

{ return fragLen;}

int MatacqTBRawEvent::getDccErrors ( ) const [inline]

Gets the contents of the DCC error field. Currently Not used for Matacq.

Returns:: dcc error

Definition at line 175 of file MatacqRawEvent.h.

References daqHeader, dccErrors32, and read32().

{ return read32(daqHeader, dccErrors32);}

unsigned MatacqTBRawEvent::getDccLen ( ) const [inline]

Gets the event length specifies in the "a la DCC" header.

Returns:: event length

Definition at line 164 of file MatacqRawEvent.h.

References daqHeader, dccLen32, and read32().

{ return read32(daqHeader, dccLen32);}

unsigned MatacqTBRawEvent::getEventId ( ) const [inline]

Gets the LV1 field contents.

Returns:: LV1 id

Definition at line 149 of file MatacqRawEvent.h.

References daqHeader, lv132, and read32().

{ return read32(daqHeader, lv132);}

int MatacqTBRawEvent::getFedId ( ) const [inline]

Gets the FED ID field contents. Should be 43.

Returns:: FED ID

Definition at line 139 of file MatacqRawEvent.h.

References daqHeader, fedId32, and read32().

{ return read32(daqHeader, fedId32);}

int MatacqTBRawEvent::getFov ( ) const [inline]

Gets the Fed event fragment data format (FOV) field content. Currently the FOV is not used for MATACQ. Note that matacq data format has its own internal version. See getMatacqDataFormatVersion()

Returns:: FOV

Definition at line 134 of file MatacqRawEvent.h.

References daqHeader, fov32, and read32().

{ return read32(daqHeader, fov32);}

int MatacqTBRawEvent::getFreqGHz ( ) const [inline]

Gets the matacq sampling frequency field contents.

Returns:: sampling frequency in GHz: 1 or 2

Definition at line 202 of file MatacqRawEvent.h.

References MatacqTBRawEvent::matacqHeader_t::freqGHz, and matacqHeader.

{ return matacqHeader->freqGHz;}

int MatacqTBRawEvent::getH1Marker ( ) const [inline]

Gets the header marker field contents. Must be 1

Returns:: H1 header marker

Definition at line 185 of file MatacqRawEvent.h.

References daqHeader, h1Marker32, and read32().

{ return read32(daqHeader, h1Marker32);}

int MatacqTBRawEvent::getMatacqDataFormatVersion ( ) const [inline]

Gets the matcq data format version

Returns:: data version

Definition at line 191 of file MatacqRawEvent.h.

References matacqHeader, and MatacqTBRawEvent::matacqHeader_t::version.

Referenced by setRawData().

{ return matacqHeader->version;}

int MatacqTBRawEvent::getParsedLen ( ) [inline]

Gets the data length in number of 64-bit words computed by the data parser.

Returns:: event length

Definition at line 222 of file MatacqRawEvent.h.

References parsedLen.

{  return parsedLen; }

unsigned MatacqTBRawEvent::getRunNum ( ) const [inline]

Gets the run number field contents.

Returns:: run number

Definition at line 180 of file MatacqRawEvent.h.

References daqHeader, read32(), and runNum32.

{ return read32(daqHeader, runNum32);}

int32_t MatacqTBRawEvent::getStatus ( void ) const [inline]

Gets the raw data status. Bitwise OR of the error flags defined by matcqError_t

Returns:: status

Definition at line 197 of file MatacqRawEvent.h.

References error.

{ return error;}

time_t MatacqTBRawEvent::getTimeStamp ( ) const [inline]

Gets the matacq data timestamp field contents:

Returns:: acquisition date of the data expressed in number of "elapsed" second since the EPOCH as defined in POSIX.1. See time() standard c function.

Definition at line 229 of file MatacqRawEvent.h.

References matacqHeader, and MatacqTBRawEvent::matacqHeader_t::timeStamp.

{ return matacqHeader->timeStamp;}

int MatacqTBRawEvent::getTriggerType ( void ) const [inline]

Gets the trigger type field contents.

Returns:: trigger type

Definition at line 154 of file MatacqRawEvent.h.

References daqHeader, read32(), and triggerType32.

{ return read32(daqHeader, triggerType32);}

int MatacqTBRawEvent::getTTrigPs ( ) const [inline]

Gets the Matacq trigger time.

Returns:: (t_trig-t_0) in ps, with t_0 the time of the first sample and t_trig the trigger time.

Definition at line 236 of file MatacqRawEvent.h.

References tTrigPs.

{ return tTrigPs;}

int MatacqTBRawEvent::read32	(	uint32le_t *	pData,
		field32spec_t	spec
	)		const `[private]`

Help function to decode header content.

Parameters:

data	pointer
spec	specification of the data field to read

Returns:: content of data field specified by 'spec'

Definition at line 104 of file MatacqRawEvent.cc.

References MatacqTBRawEvent::field32spec_t::mask, MatacqTBRawEvent::field32spec_t::offset, and query::result.

Referenced by getBoe(), getBxId(), getDccErrors(), getDccLen(), getEventId(), getFedId(), getFov(), getH1Marker(), getRunNum(), getTriggerType(), and setRawData().

                                                                         {
  int result =  pData[spec32.offset] & spec32.mask;
  int mask = spec32.mask;
  while((mask&0x1) == 0){
      mask >>= 1;
      result >>= 1;
    }
  return result;
}

void MatacqTBRawEvent::setRawData	(	const unsigned char *	buffer,
		size_t	bufferSize
	)		`[private]`

Changes the raw data pointer and updates accordingly this object.

Parameters:

buffer	new pointer to the data buffer. Must be aligned at least on 32-bit words.
size	of the data buffer.

Exceptions:

std::exception if the data cannot be decoded due to data corruption or truncation.

Definition at line 35 of file MatacqRawEvent.cc.

References channelData, daqHeader, dccLen32, error, errorLength, errorLengthConsistency, errorWrongBoe, fragLen, getBoe(), getChannelCount(), getMatacqDataFormatVersion(), matacqHeader, max(), parsedLen, read32(), AlCaHLTBitMon_QueryRunRegistry::string, and tTrigPs.

Referenced by MatacqTBRawEvent().

                                                                           {
  error = 0;
  int16le_t* begin16 = (int16le_t*) pData;
  int16le_t* pData16 = begin16;
  daqHeader = (uint32le_t*) pData16;
  const int daqHeaderLen = 16; //in bytes 
  pData16 += daqHeaderLen/sizeof(pData16[0]);
  matacqHeader = (matacqHeader_t*) pData16;
  pData16 += sizeof(matacqHeader_t)/sizeof(pData16[0]);
  if(getMatacqDataFormatVersion()>=2){//trigger position present
    tTrigPs = *((int32_t*) pData16);
    pData16 += 2;
  } else{
    tTrigPs = std::numeric_limits<int>::max();    
  }
  const int nCh = getChannelCount();
  channelData.resize(nCh);
  for(int iCh=0; iCh<nCh; ++iCh){
    //channel id:
    channelData[iCh].chId = *(pData16++);
    //number of time samples for this channel:
    channelData[iCh].nSamples = *(pData16++);
    //pointer to time sample data of this channel:
    channelData[iCh].samples = pData16;
    //moves to next channel data block:
    pData16 += channelData[iCh].nSamples;
  }
  
  //data trailer chekes:
  //FED header is aligned on 64-bit=>padding to skip
  int padding = (4-(pData16-begin16))%4;
  if(padding<0) padding+=4;
  pData16 += padding;
  uint32le_t* trailer32 = (uint32le_t*)(pData16);
  fragLen = trailer32[1]&0xFFFFFF;
  
  //std::cout << "Event fragment length including headers: " << fragLen
  //     << " 64-bit words\n";
  
  //FIXME: I am expecting the event length specifies in the header to
  //include the header, while it is not the case in current TB 2006 data
  const int nHeaders = 3;
  if(fragLen!=read32(daqHeader,dccLen32)+nHeaders
     && fragLen != read32(daqHeader,dccLen32)){
    //std::cout << "Error: fragment length is not consistent with DCC "
    //  "length\n";
    error |= errorLengthConsistency;
  }
  
  //skip trailers
  const int trailerLen = 4;
  pData16 += trailerLen;
  
  parsedLen = (pData16-begin16) / 4;

  if((pData16-begin16)!=(4*fragLen)){
    error |= errorLength;
  }

  if((size_t)(pData16-begin16)>maxSize){
    throw std::runtime_error(std::string("Corrupted or truncated data"));
  }

  //some checks
  if(getBoe()!=0x5){
    error |= errorWrongBoe;
  }
}