DCCTBDataParser Class Reference

#include <DCCDataParser.h>

Public Types
enum	DCCDataParserGlobalFields { EMPTYEVENTSIZE = 32 }

Public Member Functions
std::pair< uint32_t, uint32_t >	checkEventLength (const uint32_t *pointerToEvent, uint32_t bytesToEnd, bool singleEvent=false)
std::vector< DCCTBEventBlock * > &	dccEvents ()
uint32_t	dccId ()
	DCCTBDataParser (const std::vector< uint32_t > &parserParameters, bool parseInternalData=true, bool debug=true)
bool	debug ()
std::map< std::string, uint32_t > &	errorCounters ()
std::vector< std::pair< uint32_t, std::pair< const uint32_t *, uint32_t > > >	events ()
const uint32_t *	getBuffer ()
std::string	getDecString (uint32_t data)
std::string	getHexString (uint32_t data)
std::string	getIndexedData (uint32_t indexed, uint32_t *pointer)
std::string	index (uint32_t position)
DCCTBDataMapper *	mapper ()
uint32_t	numbSRF ()
uint32_t	numbTriggerSamples ()
uint32_t	numbTTs ()
uint32_t	numbXtalSamples ()
void	parseBuffer (const uint32_t *buffer, uint32_t bufferSize, bool singleEvent=false)
void	parseFile (std::string fileName, bool singleEvent=false)
std::vector< uint32_t >	parserParameters ()
void	resetErrorCounters ()
void	setParameters (const std::vector< uint32_t > &newParameters)
uint32_t	srpBlockSize ()
uint32_t	srpId ()
uint32_t	tcc1Id ()
uint32_t	tcc2Id ()
uint32_t	tcc3Id ()
uint32_t	tcc4Id ()
uint32_t	tccBlockSize ()
	~DCCTBDataParser ()

Protected Types
enum	DCCTBDataParserFields {   EVENTLENGTHMASK = 0xFFFFFF, BOEBEGIN = 28, BOEMASK = 0xF, BOE = 0x5,   EOEBEGIN = 28, EOEMASK = 0xF, EOE = 0xA }

Protected Member Functions
void	computeBlockSizes ()

Protected Attributes
const uint32_t *	buffer_
uint32_t	bufferSize_
std::vector< DCCTBEventBlock * >	dccEvents_
bool	debug_
std::map< std::string, uint32_t >	errors_
std::string	eventErrors_
std::vector< std::pair< uint32_t, std::pair< const uint32_t *, uint32_t > > >	events_
DCCTBDataMapper *	mapper_
std::vector< uint32_t >	parameters
bool	parseInternalData_
uint32_t	processedEvent_
uint32_t	srpBlockSize_
uint32_t	tccBlockSize_

Detailed Description

Definition at line 25 of file DCCDataParser.h.

Member Enumeration Documentation

DCCDataParserGlobalFields

enum DCCTBDataParser::DCCDataParserGlobalFields

Enumerator
EMPTYEVENTSIZE

Definition at line 132 of file DCCDataParser.h.

                                 {
    EMPTYEVENTSIZE = 32  //bytes
  };

DCCTBDataParserFields

enum DCCTBDataParser::DCCTBDataParserFields

protected

Enumerator
EVENTLENGTHMASK
BOEBEGIN
BOEMASK
BOE
EOEBEGIN
EOEMASK
EOE

Definition at line 159 of file DCCDataParser.h.

                             {
    EVENTLENGTHMASK = 0xFFFFFF,

    BOEBEGIN = 28,  //begin of event (on 32 bit string starts at bit 28)
    BOEMASK = 0xF,  //mask is 4 bits (F)
    BOE = 0x5,      //B'0101'

    EOEBEGIN = 28,  //end of event
    EOEMASK = 0xF,  //4 bits
    EOE = 0xA       //B'1010'
  };

Constructor & Destructor Documentation

DCCTBDataParser()

DCCTBDataParser::DCCTBDataParser	(	const std::vector< uint32_t > &	parserParameters,
		bool	parseInternalData = true,
		bool	debug = true
	)

Class constructor: takes a vector of 10 parameters and flags for parseInternalData and debug Parameters are: 0 - crystal samples (default is 10) 1 - number of trigger time samples (default is 1) 2 - number of TT (default is 68) 3 - number of SR Flags (default is 68) 4 - DCC id 5 - SR id [6-9] - TCC[6-9] id

Definition at line 7 of file DCCDataParser.cc.

References computeBlockSizes(), mapper_, and resetErrorCounters().

    : buffer_(nullptr), parseInternalData_(parseInternalData), debug_(debug), parameters(parserParameters) {
  mapper_ = new DCCTBDataMapper(this);  //build a new data mapper
  resetErrorCounters();                 //restart error counters
  computeBlockSizes();                  //calculate block sizes
}

~DCCTBDataParser()

DCCTBDataParser::~DCCTBDataParser

(

)

Class destructor

Definition at line 331 of file DCCDataParser.cc.

References dccEvents_, and mapper_.

                                  {
  // delete DCCTBEvents if any...
  std::vector<DCCTBEventBlock *>::iterator it;
  for (it = dccEvents_.begin(); it != dccEvents_.end(); it++) {
    delete *it;
  }
  dccEvents_.clear();

  delete mapper_;
}

Member Function Documentation

checkEventLength()

std::pair< uint32_t, uint32_t > DCCTBDataParser::checkEventLength	(	const uint32_t *	pointerToEvent,
		uint32_t	bytesToEnd,
		bool	singleEvent = false
	)

Check if EVENT LENGTH is coeherent and if BOE/EOE are correctly written returns 3 bits code with the error found + event length

Definition at line 206 of file DCCDataParser.cc.

References BOE, BOEBEGIN, BOEMASK, EMPTYEVENTSIZE, EOEBEGIN, EOEMASK, errors_, EVENTLENGTHMASK, events_, getDecString(), mps_fire::result, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by parseBuffer().

                                                                                  {
  std::pair<uint32_t, uint32_t> result;  //returns error mask and event length
  uint32_t errorMask(0);                 //error mask to return

  //check begin of event (BOE bits field)
  //(Note: we have to add one to read the 2nd 32 bit word where BOE is written)
  const uint32_t *boePointer = pointerToEvent + 1;
  if ((((*boePointer) >> BOEBEGIN) & BOEMASK) != BOE) {
    (errors_["DCC::BOE"])++;
    errorMask = 1;
  }

  //get Event Length from buffer (Note: we have to add two to read the 3rd 32 bit word where EVENT LENGTH is written)
  const uint32_t *myPointer = pointerToEvent + 2;
  uint32_t eventLength = (*myPointer) & EVENTLENGTHMASK;

  // std::cout << " Event Length(from decoding) = " << dec << eventLength << "... bytes to end... " << bytesToEnd << ", event numb : " << processedEvent_ << std::endl;

  bool eoeError = false;

  //check if event is empty but but EVENT LENGTH is not corresponding to it
  if (singleEvent && eventLength != bytesToEnd / 8) {
    eventLength = bytesToEnd / 8;
    (errors_["DCC::EVENT LENGTH"])++;
    errorMask = errorMask | (1 << 1);
  }
  //check if event length mismatches the number of words written as data
  else if (eventLength == 0 || eventLength > (bytesToEnd / 8) || eventLength < (EMPTYEVENTSIZE / 8)) {
    // How to handle bad event length in multiple event buffers
    // First approach : Send an exception
    // Second aproach : Try to find the EOE (To be done? If yes check dataDecoder tBeam implementation)
    std::string fatalError;

    fatalError += "\n ======================================================================";
    fatalError += "\n Fatal error at event = " + getDecString(events_.size() + 1);
    fatalError += "\n Decoded event length = " + getDecString(eventLength);
    fatalError += "\n bytes to buffer end  = " + getDecString(bytesToEnd);
    fatalError += "\n Unable to procead the data decoding ...";

    if (eventLength > (bytesToEnd / 8)) {
      fatalError += " (eventLength > (bytesToEnd / 8)";
    } else {
      fatalError += "\n event length not big enough heaven to build an empty event ( 4x8 bytes)";
    }

    fatalError += "\n ======================================================================";

    throw ECALTBParserException(fatalError);
  }

  //check end of event (EOE bits field)
  //(Note: event length is multiplied by 2 because its written as 32 bit words and not 64 bit words)
  const uint32_t *endOfEventPointer = pointerToEvent + eventLength * 2 - 1;
  if ((((*endOfEventPointer) >> EOEBEGIN & EOEMASK) != EOEMASK) && !eoeError) {
    (errors_["DCC::EOE"])++;
    errorMask = errorMask | (1 << 2);
  }

  //build result to return
  result.first = errorMask;
  result.second = eventLength;

  return result;
}

computeBlockSizes()

void DCCTBDataParser::computeBlockSizes ( )

protected

Definition at line 29 of file DCCDataParser.cc.

References l1trig_cff::nTT, numbSRF(), numbTriggerSamples(), numbTTs(), srpBlockSize_, and tccBlockSize_.

Referenced by DCCTBDataParser(), and setParameters().

                                        {
  uint32_t nTT = numbTTs();                  //gets the number of the trigger towers (default:68)
  uint32_t tSamples = numbTriggerSamples();  //gets the number of trigger time samples (default: 1)
  uint32_t nSr = numbSRF();                  //gests the number of SR flags (default:68)

  uint32_t tf(0), srf(0);

  if ((nTT * tSamples) < 4 || (nTT * tSamples) % 4)
    tf = 1;  //test is there is no TTC primitives or if it's a multiple of 4?
  else
    tf = 0;

  if (srf < 16 || srf % 16)
    srf = 1;  //??? by default srf=0 why do we make this test ?????
  else
    srf = 0;

  //TTC block size: header (8 bytes) + 17 words with 4 trigger primitives (17*8bytes)
  tccBlockSize_ = 8 + ((nTT * tSamples) / 4) * 8 + tf * 8;

  //SR block size: header (8 bytes) + 4 words with 16 SR flags + 1 word with 4 SR flags (5*8bytes)
  srpBlockSize_ = 8 + (nSr / 16) * 8 + srf * 8;
}

dccEvents()

std::vector< DCCTBEventBlock * > & DCCTBDataParser::dccEvents ( )

inline

Get method for DCCEventBlocks vector

Definition at line 195 of file DCCDataParser.h.

References dccEvents_.

Referenced by EcalTBDaqFormatter::interpretRawData(), and EcalTB07DaqFormatter::interpretRawData().

{ return dccEvents_; }

dccId()

uint32_t DCCTBDataParser::dccId ( )

inline

Definition at line 179 of file DCCDataParser.h.

References parameters.

{ return parameters[4]; }

debug()

bool DCCTBDataParser::debug ( )

inline

Get methods for debug flag

Definition at line 194 of file DCCDataParser.h.

References debug_.

Referenced by DCCTBEventBlock::DCCTBEventBlock(), DCCTBSRPBlock::DCCTBSRPBlock(), DCCTBTCCBlock::DCCTBTCCBlock(), DCCTBXtalBlock::DCCTBXtalBlock(), DCCTBXtalBlock::increment(), DCCTBSRPBlock::increment(), DCCTBTCCBlock::increment(), and DCCTBTowerBlock::parseXtalData().

{ return debug_; }

errorCounters()

std::map< std::string, uint32_t > & DCCTBDataParser::errorCounters ( )

inline

Get method for error counters map

Definition at line 196 of file DCCDataParser.h.

References errors_.

{ return errors_; }

events()

std::vector< std::pair< uint32_t, std::pair< const uint32_t *, uint32_t > > > DCCTBDataParser::events ( )

inline

Get method for events

Definition at line 197 of file DCCDataParser.h.

References events_.

                                                                                                   {
  return events_;
}

getBuffer()

const uint32_t* DCCTBDataParser::getBuffer ( )

inline

Retrieves a pointer to the data buffer

Definition at line 125 of file DCCDataParser.h.

References buffer_.

{ return buffer_; }

getDecString()

std::string DCCTBDataParser::getDecString

(

uint32_t

data

)

Methods to get data strings formatted as decimal/hexadecimal, indexes and indexed data

Definition at line 290 of file DCCDataParser.cc.

References edmScanValgrind::buffer, data, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by DCCTBDataMapper::buildDCCFields(), DCCTBDataMapper::buildSRPFields(), DCCTBDataMapper::buildTCCFields(), DCCTBDataMapper::buildXtalFields(), DCCTBBlockPrototype::checkDataField(), checkEventLength(), DCCTBEventBlock::dataCheck(), DCCTBTowerBlock::dataCheck(), DCCTBTCCBlock::dataCheck(), DCCTBEventBlock::DCCTBEventBlock(), DCCTBEventBlock::eventErrorString(), parseBuffer(), DCCTBBlockPrototype::parseData(), DCCTBTowerBlock::parseXtalData(), DCCTBTCCBlock::triggerFlags(), DCCTBTCCBlock::triggerSamples(), and DCCTBXtalBlock::xtalDataSamples().

                                                    {
  char buffer[15];
  long unsigned int data = dat;
  snprintf(buffer, sizeof(buffer), "%lu", data);

  return std::string(buffer);
}

getHexString()

std::string DCCTBDataParser::getHexString

(

uint32_t

data

)

Definition at line 302 of file DCCDataParser.cc.

References edmScanValgrind::buffer, data, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by getIndexedData().

                                                     {
  char buffer[15];
  snprintf(buffer, sizeof(buffer), "0x%08x", (uint16_t)(data));

  return std::string(buffer);
}

getIndexedData()

std::string DCCTBDataParser::getIndexedData	(	uint32_t	indexed,
		uint32_t *	pointer
	)

Definition at line 313 of file DCCDataParser.cc.

References getHexString(), index(), position, runTheMatrix::ret, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                              {
  std::string ret;

  //char indexBuffer[20];
  //char dataBuffer[20];
  //sprintf(indexBuffer,"W[%08u] = ",position);
  //sprintf(dataBuffer,"0x%08x",*pointer);
  //ret = std::string(indexBuffer)+std::string(dataBuffer);

  ret = index(position) + getHexString(*pointer);

  return ret;
}

index()

std::string DCCTBDataParser::index

(

uint32_t

position

)

Definition at line 277 of file DCCDataParser.cc.

References position, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by getIndexedData(), and BeautifulSoup.PageElement::insert().

                                                  {
  char indexBuffer[20];
  long unsigned int pos = position;
  snprintf(
      indexBuffer, sizeof(indexBuffer), "W[%08lu]", pos);  //build an index string for display purposes, p.e.  W[15]

  return std::string(indexBuffer);
}

mapper()

DCCTBDataMapper * DCCTBDataParser::mapper ( )

inline

Get method for DCCTBDataMapper

Definition at line 172 of file DCCDataParser.h.

References mapper_.

Referenced by DCCTBEventBlock::DCCTBEventBlock(), DCCTBSRPBlock::DCCTBSRPBlock(), DCCTBTCCBlock::DCCTBTCCBlock(), DCCTBTowerBlock::DCCTBTowerBlock(), DCCTBTrailerBlock::DCCTBTrailerBlock(), and DCCTBXtalBlock::DCCTBXtalBlock().

{ return mapper_; }

numbSRF()

uint32_t DCCTBDataParser::numbSRF ( )

inline

Definition at line 178 of file DCCDataParser.h.

References parameters.

Referenced by computeBlockSizes(), and DCCTBSRPBlock::DCCTBSRPBlock().

{ return parameters[3]; }

numbTriggerSamples()

uint32_t DCCTBDataParser::numbTriggerSamples ( )

inline

Definition at line 176 of file DCCDataParser.h.

References parameters.

Referenced by DCCTBDataMapper::buildTCCFields(), and computeBlockSizes().

{ return parameters[1]; }

numbTTs()

uint32_t DCCTBDataParser::numbTTs ( )

inline

Definition at line 177 of file DCCDataParser.h.

References parameters.

Referenced by computeBlockSizes(), DCCTBTCCBlock::DCCTBTCCBlock(), DCCTBTCCBlock::triggerFlags(), and DCCTBTCCBlock::triggerSamples().

{ return parameters[2]; }

numbXtalSamples()

uint32_t DCCTBDataParser::numbXtalSamples ( )

inline

Definition at line 175 of file DCCDataParser.h.

References parameters.

Referenced by DCCTBDataMapper::buildXtalFields(), DCCTBTowerBlock::parseXtalData(), and DCCTBXtalBlock::xtalDataSamples().

{ return parameters[0]; }

parseBuffer()

void DCCTBDataParser::parseBuffer	(	const uint32_t *	buffer,
		uint32_t	bufferSize,
		bool	singleEvent = false
	)

Parse data from a buffer

Definition at line 104 of file DCCDataParser.cc.

References edmScanValgrind::buffer, buffer_, checkEventLength(), dccEvents_, EMPTYEVENTSIZE, eventErrors_, events_, getDecString(), parseInternalData_, processedEvent_, resetErrorCounters(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by EcalTBDaqFormatter::interpretRawData(), EcalTB07DaqFormatter::interpretRawData(), and parseFile().

                                                                                               {
  resetErrorCounters();  //reset error counters

  buffer_ = buffer;  //set class buffer

  //clear stored data
  processedEvent_ = 0;
  events_.clear();
  std::vector<DCCTBEventBlock *>::iterator it;
  for (it = dccEvents_.begin(); it != dccEvents_.end(); it++) {
    delete *it;
  }
  dccEvents_.clear();
  eventErrors_ = "";

  //for debug purposes
  //std::cout << std::endl << "Now in DCCTBDataParser::parseBuffer" << std::endl;
  //std::cout << std::endl << "Buffer Size:" << dec << bufferSize << std::endl;

  //check if we have a coherent buffer size
  if (bufferSize % 8) {
    std::string fatalError;
    fatalError += "\n ======================================================================";
    fatalError += "\n Fatal error at event = " + getDecString(events_.size() + 1);
    fatalError += "\n Buffer Size of = " + getDecString(bufferSize) + "[bytes] is not divisible by 8 ... ";
    fatalError += "\n ======================================================================";
    throw ECALTBParserException(fatalError);
  }
  if (bufferSize < EMPTYEVENTSIZE) {
    std::string fatalError;
    fatalError += "\n ======================================================================";
    fatalError += "\n Fatal error at event = " + getDecString(events_.size() + 1);
    fatalError += "\n Buffer Size of = " + getDecString(bufferSize) + "[bytes] is less than an empty event ... ";
    fatalError += "\n ======================================================================";
    throw ECALTBParserException(fatalError);
  }

  const uint32_t *myPointer = buffer_;

  //  uint32_t processedBytes(0), wordIndex(0), lastEvIndex(0),eventSize(0), eventLength(0), errorMask(0);
  uint32_t processedBytes(0), wordIndex(0), eventLength(0), errorMask(0);

  //parse until there are no more events
  while (processedBytes + EMPTYEVENTSIZE <= bufferSize) {
    //for debug purposes
    //std::cout << "-> processedBytes.  =   " << dec << processedBytes << std::endl;
    //std::cout << " -> Processed Event index =   " << dec << processedEvent_ << std::endl;
    //std::cout << "-> First ev.word    = 0x" << hex << (*myPointer) << std::endl;
    //std::cout << "-> word index       =   " << dec << wordIndex << std::endl;

    //check if Event Length is coherent /////////////////////////////////////////
    uint32_t bytesToEnd = bufferSize - processedBytes;
    std::pair<uint32_t, uint32_t> eventD = checkEventLength(myPointer, bytesToEnd, singleEvent);
    eventLength = eventD.second;
    errorMask = eventD.first;

    //for debug purposes
    //std::cout <<" -> EventSizeBytes        =   " << dec << eventLength*8 << std::endl;

    //for debug purposes debug
    //std::cout<<std::endl;
    //std::cout<<" out... Bytes To End.... =   "<<dec<<bytesToEnd<<std::endl;
    //std::cout<<" out... Processed Event  =   "<<dec<<processedEvent_<<std::endl;
    //std::cout<<" out... Event Length     =   "<<dec<<eventLength<<std::endl;
    //std::cout<<" out... LastWord         = 0x"<<hex<<*(myPointer+eventLength*2-1)<<std::endl;

    if (parseInternalData_) {
      //build a new event block from buffer
      DCCTBEventBlock *myBlock =
          new DCCTBEventBlock(this, myPointer, eventLength * 8, eventLength * 2 - 1, wordIndex, 0);

      //add event to dccEvents vector
      dccEvents_.push_back(myBlock);
    }

    //build the event pointer with error mask and add it to the events vector
    std::pair<const uint32_t *, uint32_t> eventPointer(myPointer, eventLength);
    std::pair<uint32_t, std::pair<const uint32_t *, uint32_t> > eventPointerWithErrorMask(errorMask, eventPointer);
    events_.push_back(eventPointerWithErrorMask);

    //update processed buffer size
    processedEvent_++;
    processedBytes += eventLength * 8;
    //std::cout << std::endl << "Processed Bytes = " << dec << processedBytes << std::endl;

    //go to next event
    myPointer += eventLength * 2;
    wordIndex += eventLength * 2;
  }
}

parseFile()

void DCCTBDataParser::parseFile	(	std::string	fileName,
		bool	singleEvent = false
	)

Parse data from file

Definition at line 57 of file DCCDataParser.cc.

References bufferSize_, MillePedeFileConverter_cfg::fileName, mps_fire::i, makeListRunsInFiles::inputFile, makeListRunsInFiles::myData, parseBuffer(), resetErrorCounters(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                    {
  std::ifstream inputFile;  //open file as input
  inputFile.open(fileName.c_str());

  resetErrorCounters();  //reset error counters

  //for debug purposes
  //std::cout << "Now in DCCTBDataParser::parseFile " << std::endl;

  //if file opened correctly read data to a buffer and parse it
  //else throw an exception
  if (!inputFile.fail()) {
    std::string myWord;                   //word read from line
    std::vector<std::string> dataVector;  //data vector

    //until the end of file read each line as a string and add it to the data vector
    while (inputFile >> myWord) {
      dataVector.push_back(myWord);
    }

    bufferSize_ = (dataVector.size()) * 4;  //buffer size in bytes (note:each char is an hex number)

    uint32_t *myData = new uint32_t[dataVector.size()];  //allocate memory for a new data buffer
    uint32_t *const myDataBeginning = myData;            //pointer that stays at the beginning of the allocated memory

    //fill buffer data with data from file lines
    for (uint32_t i = 1; i <= dataVector.size(); i++, myData++) {
      sscanf((dataVector[i - 1]).c_str(), "%x", myData);

      //for debug purposes
      //std::cout << std::endl << "Data position: " << dec << i << " val = " << getHexString(*myData);
    }

    inputFile.close();  //close file

    parseBuffer(myData, bufferSize_, singleEvent);  //parse data from the newly filled myData
    delete[] myDataBeginning;
  } else {
    std::string errorMessage = std::string(" Error::Unable to open file :") + fileName;
    throw ECALTBParserException(errorMessage);
  }
}

parserParameters()

std::vector< uint32_t > DCCTBDataParser::parserParameters ( )

inline

Get methods for parser parameters;

Definition at line 174 of file DCCDataParser.h.

References parameters.

{ return parameters; }

resetErrorCounters()

void DCCTBDataParser::resetErrorCounters

(

)

Reset Error Counters

Definition at line 18 of file DCCDataParser.cc.

References errors_.

Referenced by DCCTBDataParser(), parseBuffer(), and parseFile().

                                         {
  //set error counters to 0
  errors_["DCC::BOE"] = 0;           //begin of event (header B[60-63])
  errors_["DCC::EOE"] = 0;           //end of event (trailer B[60-63])
  errors_["DCC::EVENT LENGTH"] = 0;  //event length (trailer B[32-55])
}

setParameters()

void DCCTBDataParser::setParameters ( const std::vector< uint32_t > &  newParameters )

inline

Set method for parser parameters

Definition at line 186 of file DCCDataParser.h.

References computeBlockSizes(), and parameters.

                                                                                   {
  parameters = newParameters;
  computeBlockSizes();
}

srpBlockSize()

uint32_t DCCTBDataParser::srpBlockSize ( )

inline

Get methods for block sizes

Definition at line 191 of file DCCDataParser.h.

References srpBlockSize_.

Referenced by DCCTBEventBlock::DCCTBEventBlock().

{ return srpBlockSize_; }

srpId()

uint32_t DCCTBDataParser::srpId ( )

inline

Definition at line 180 of file DCCDataParser.h.

References parameters.

Referenced by DCCTBSRPBlock::dataCheck().

{ return parameters[5]; }

tcc1Id()

uint32_t DCCTBDataParser::tcc1Id ( )

inline

Definition at line 181 of file DCCDataParser.h.

References parameters.

Referenced by DCCTBEventBlock::DCCTBEventBlock().

{ return parameters[6]; }

tcc2Id()

uint32_t DCCTBDataParser::tcc2Id ( )

inline

Definition at line 182 of file DCCDataParser.h.

References parameters.

Referenced by DCCTBEventBlock::DCCTBEventBlock().

{ return parameters[7]; }

tcc3Id()

uint32_t DCCTBDataParser::tcc3Id ( )

inline

Definition at line 183 of file DCCDataParser.h.

References parameters.

Referenced by DCCTBEventBlock::DCCTBEventBlock().

{ return parameters[8]; }

tcc4Id()

uint32_t DCCTBDataParser::tcc4Id ( )

inline

Definition at line 184 of file DCCDataParser.h.

References parameters.

Referenced by DCCTBEventBlock::DCCTBEventBlock().

{ return parameters[9]; }

tccBlockSize()

uint32_t DCCTBDataParser::tccBlockSize ( )

inline

Definition at line 192 of file DCCDataParser.h.

References tccBlockSize_.

Referenced by DCCTBEventBlock::DCCTBEventBlock().

{ return tccBlockSize_; }

Member Data Documentation

buffer_

const uint32_t* DCCTBDataParser::buffer_

protected

Definition at line 139 of file DCCDataParser.h.

Referenced by getBuffer(), and parseBuffer().

bufferSize_

uint32_t DCCTBDataParser::bufferSize_

protected

Definition at line 140 of file DCCDataParser.h.

Referenced by parseFile().

dccEvents_

std::vector<DCCTBEventBlock *> DCCTBDataParser::dccEvents_

protected

Definition at line 149 of file DCCDataParser.h.

Referenced by dccEvents(), parseBuffer(), and ~DCCTBDataParser().

debug_

bool DCCTBDataParser::debug_

protected

Definition at line 155 of file DCCDataParser.h.

Referenced by debug().

errors_

std::map<std::string, uint32_t> DCCTBDataParser::errors_

protected

Definition at line 156 of file DCCDataParser.h.

Referenced by checkEventLength(), errorCounters(), and resetErrorCounters().

eventErrors_

std::string DCCTBDataParser::eventErrors_

protected

Definition at line 146 of file DCCDataParser.h.

Referenced by parseBuffer().

events_

std::vector<std::pair<uint32_t, std::pair<const uint32_t *, uint32_t> > > DCCTBDataParser::events_

protected

Definition at line 152 of file DCCDataParser.h.

Referenced by checkEventLength(), events(), and parseBuffer().

mapper_

DCCTBDataMapper* DCCTBDataParser::mapper_

protected

Definition at line 147 of file DCCDataParser.h.

Referenced by DCCTBDataParser(), mapper(), and ~DCCTBDataParser().

parameters

std::vector<uint32_t> DCCTBDataParser::parameters

protected

Definition at line 157 of file DCCDataParser.h.

Referenced by dccId(), numbSRF(), numbTriggerSamples(), numbTTs(), numbXtalSamples(), parserParameters(), setParameters(), srpId(), tcc1Id(), tcc2Id(), tcc3Id(), and tcc4Id().

parseInternalData_

bool DCCTBDataParser::parseInternalData_

protected

Definition at line 154 of file DCCDataParser.h.

Referenced by parseBuffer().

processedEvent_

uint32_t DCCTBDataParser::processedEvent_

protected

Definition at line 145 of file DCCDataParser.h.

Referenced by parseBuffer().

srpBlockSize_

uint32_t DCCTBDataParser::srpBlockSize_

protected

Definition at line 142 of file DCCDataParser.h.

Referenced by computeBlockSizes(), and srpBlockSize().

tccBlockSize_

uint32_t DCCTBDataParser::tccBlockSize_

protected

Definition at line 143 of file DCCDataParser.h.

Referenced by computeBlockSizes(), and tccBlockSize().