CMS 3D CMS Logo

List of all members | Public Types | Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes
DCCTBDataParser Class Reference

#include <DCCDataParser.h>

Public Types

enum  DCCDataParserGlobalFields { EMPTYEVENTSIZE = 32 }
 

Public Member Functions

std::pair< uint32_t, uint32_t > checkEventLength (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< uint32_t *, uint32_t > > > events ()
 
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)
 
DCCTBDataMappermapper ()
 
uint32_t numbSRF ()
 
uint32_t numbTriggerSamples ()
 
uint32_t numbTTs ()
 
uint32_t numbXtalSamples ()
 
void parseBuffer (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

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< uint32_t *, uint32_t > > > events_
 
DCCTBDataMappermapper_
 
std::vector< uint32_t > parameters
 
bool parseInternalData_
 
uint32_t processedEvent_
 
uint32_t srpBlockSize_
 
uint32_t tccBlockSize_
 

Detailed Description

Definition at line 27 of file DCCDataParser.h.

Member Enumeration Documentation

Enumerator
EMPTYEVENTSIZE 

Definition at line 138 of file DCCDataParser.h.

138  {
139  EMPTYEVENTSIZE = 32 //bytes
140  };
Enumerator
EVENTLENGTHMASK 
BOEBEGIN 
BOEMASK 
BOE 
EOEBEGIN 
EOEMASK 
EOE 

Definition at line 165 of file DCCDataParser.h.

165  {
166  EVENTLENGTHMASK = 0xFFFFFF,
167 
168  BOEBEGIN = 28, //begin of event (on 32 bit string starts at bit 28)
169  BOEMASK = 0xF, //mask is 4 bits (F)
170  BOE =0x5, //B'0101'
171 
172  EOEBEGIN = 28, //end of event
173  EOEMASK = 0xF, //4 bits
174  EOE =0xA //B'1010'
175  };

Constructor & Destructor Documentation

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 9 of file DCCDataParser.cc.

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

9  :
11 
12  mapper_ = new DCCTBDataMapper(this); //build a new data mapper
13  resetErrorCounters(); //restart error counters
14  computeBlockSizes(); //calculate block sizes
15 
16 }
void resetErrorCounters()
void computeBlockSizes()
std::vector< uint32_t > parameters
std::vector< uint32_t > parserParameters()
DCCTBDataMapper * mapper_
uint32_t * buffer_
DCCTBDataParser::~DCCTBDataParser ( )

Class destructor

Definition at line 347 of file DCCDataParser.cc.

References dccEvents_, and mapper_.

Referenced by getBuffer().

347  {
348 
349  // delete DCCTBEvents if any...
350  std::vector<DCCTBEventBlock *>::iterator it;
351  for(it=dccEvents_.begin();it!=dccEvents_.end();it++){delete *it;}
352  dccEvents_.clear();
353 
354  delete mapper_;
355 }
std::vector< DCCTBEventBlock * > dccEvents_
DCCTBDataMapper * mapper_

Member Function Documentation

std::pair< uint32_t, uint32_t > DCCTBDataParser::checkEventLength ( 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 218 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().

218  {
219 
220  std::pair<uint32_t,uint32_t> result; //returns error mask and event length
221  uint32_t errorMask(0); //error mask to return
222 
223  //check begin of event (BOE bits field)
224  //(Note: we have to add one to read the 2nd 32 bit word where BOE is written)
225  uint32_t *boePointer = pointerToEvent + 1;
226  if( ( ((*boePointer)>>BOEBEGIN)& BOEMASK ) != BOE ) {
227  (errors_["DCC::BOE"])++; errorMask = 1;
228  }
229 
230 
231  //get Event Length from buffer (Note: we have to add two to read the 3rd 32 bit word where EVENT LENGTH is written)
232  uint32_t * myPointer = pointerToEvent + 2;
233  uint32_t eventLength = (*myPointer)&EVENTLENGTHMASK;
234 
235  // std::cout << " Event Length(from decoding) = " << dec << eventLength << "... bytes to end... " << bytesToEnd << ", event numb : " << processedEvent_ << std::endl;
236 
237  bool eoeError = false;
238 
239  //check if event is empty but but EVENT LENGTH is not corresponding to it
240  if( singleEvent && eventLength != bytesToEnd/8 ){
241  eventLength = bytesToEnd/8;
242  (errors_["DCC::EVENT LENGTH"])++;
243  errorMask = errorMask | (1<<1);
244  }
245  //check if event length mismatches the number of words written as data
246  else if( eventLength == 0 || eventLength > (bytesToEnd / 8) || eventLength < (EMPTYEVENTSIZE/8) ){
247  // How to handle bad event length in multiple event buffers
248  // First approach : Send an exception
249  // Second aproach : Try to find the EOE (To be done? If yes check dataDecoder tBeam implementation)
250  std::string fatalError;
251 
252  fatalError +="\n ======================================================================";
253  fatalError +="\n Fatal error at event = " + getDecString(events_.size()+1);
254  fatalError +="\n Decoded event length = " + getDecString(eventLength);
255  fatalError +="\n bytes to buffer end = " + getDecString(bytesToEnd);
256  fatalError +="\n Unable to procead the data decoding ...";
257 
258  if(eventLength > (bytesToEnd / 8)){ fatalError +=" (eventLength > (bytesToEnd / 8)";}
259  else{ fatalError += "\n event length not big enough heaven to build an empty event ( 4x8 bytes)";}
260 
261  fatalError +="\n ======================================================================";
262 
263  throw ECALTBParserException(fatalError);
264  }
265 
266  //check end of event (EOE bits field)
267  //(Note: event length is multiplied by 2 because its written as 32 bit words and not 64 bit words)
268  uint32_t *endOfEventPointer = pointerToEvent + eventLength*2 -1;
269  if ( ( ((*endOfEventPointer) >> EOEBEGIN & EOEMASK ) != EOEMASK) && !eoeError ){
270  (errors_["DCC::EOE"])++;
271  errorMask = errorMask | (1<<2);
272  }
273 
274  //build result to return
275  result.first = errorMask;
276  result.second = eventLength;
277 
278  return result;
279 }
std::map< std::string, uint32_t > errors_
std::string getDecString(uint32_t data)
std::vector< std::pair< uint32_t, std::pair< uint32_t *, uint32_t > > > events_
void DCCTBDataParser::computeBlockSizes ( )
protected

Definition at line 35 of file DCCDataParser.cc.

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

Referenced by DCCTBDataParser(), and setParameters().

35  {
36  uint32_t nTT = numbTTs(); //gets the number of the trigger towers (default:68)
37  uint32_t tSamples = numbTriggerSamples(); //gets the number of trigger time samples (default: 1)
38  uint32_t nSr = numbSRF(); //gests the number of SR flags (default:68)
39 
40  uint32_t tf(0), srf(0);
41 
42  if( (nTT*tSamples)<4 || (nTT*tSamples)%4 ) tf=1; //test is there is no TTC primitives or if it's a multiple of 4?
43  else tf=0;
44 
45 
46  if( srf<16 || srf%16 ) srf=1; //??? by default srf=0 why do we make this test ?????
47  else srf=0;
48 
49  //TTC block size: header (8 bytes) + 17 words with 4 trigger primitives (17*8bytes)
50  tccBlockSize_ = 8 + ((nTT*tSamples)/4)*8 + tf*8 ;
51 
52  //SR block size: header (8 bytes) + 4 words with 16 SR flags + 1 word with 4 SR flags (5*8bytes)
53  srpBlockSize_ = 8 + (nSr/16)*8 + srf*8;
54 }
uint32_t tccBlockSize_
uint32_t numbTriggerSamples()
#define nTT
Definition: TMEGeom.h:6
uint32_t srpBlockSize_
uint32_t numbTTs()
uint32_t numbSRF()
std::vector< DCCTBEventBlock * > & DCCTBDataParser::dccEvents ( )
inline

Get method for DCCEventBlocks vector

Definition at line 199 of file DCCDataParser.h.

References dccEvents_.

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

199 { return dccEvents_; }
std::vector< DCCTBEventBlock * > dccEvents_
uint32_t DCCTBDataParser::dccId ( )
inline

Definition at line 186 of file DCCDataParser.h.

References parameters.

186 { return parameters[4]; }
std::vector< uint32_t > parameters
bool DCCTBDataParser::debug ( )
inline
std::map< std::string, uint32_t > & DCCTBDataParser::errorCounters ( )
inline

Get method for error counters map

Definition at line 200 of file DCCDataParser.h.

References errors_.

200 { return errors_; }
std::map< std::string, uint32_t > errors_
std::vector< std::pair< uint32_t, std::pair< uint32_t *, uint32_t > > > DCCTBDataParser::events ( )
inline

Get method for events

Definition at line 201 of file DCCDataParser.h.

References events_.

201 { return events_; }
std::vector< std::pair< uint32_t, std::pair< uint32_t *, uint32_t > > > events_
uint32_t* DCCTBDataParser::getBuffer ( )
inline

Retrieves a pointer to the data buffer

Definition at line 131 of file DCCDataParser.h.

References buffer_, and ~DCCTBDataParser().

131 { return buffer_;}
uint32_t * buffer_
std::string DCCTBDataParser::getDecString ( uint32_t  data)
std::string DCCTBDataParser::getHexString ( uint32_t  data)

Definition at line 315 of file DCCDataParser.cc.

References AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by getIndexedData().

315  {
316 
317  char buffer[15];
318  snprintf(buffer, sizeof(buffer), "0x%08x",(uint16_t)(data));
319 
320  return std::string(buffer);
321 }
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:82
std::string DCCTBDataParser::getIndexedData ( uint32_t  indexed,
uint32_t *  pointer 
)

Definition at line 328 of file DCCDataParser.cc.

References getHexString(), index(), and AlCaHLTBitMon_QueryRunRegistry::string.

328  {
329  std::string ret;
330 
331  //char indexBuffer[20];
332  //char dataBuffer[20];
333  //sprintf(indexBuffer,"W[%08u] = ",position);
334  //sprintf(dataBuffer,"0x%08x",*pointer);
335  //ret = std::string(indexBuffer)+std::string(dataBuffer);
336 
337  ret = index(position) + getHexString(*pointer);
338 
339  return ret;
340 }
std::string getHexString(uint32_t data)
static int position[264][3]
Definition: ReadPGInfo.cc:509
std::string index(uint32_t position)
std::string DCCTBDataParser::index ( uint32_t  position)

Definition at line 287 of file DCCDataParser.cc.

References position, and AlCaHLTBitMon_QueryRunRegistry::string.

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

287  {
288 
289  char indexBuffer[20];
290  long unsigned int pos = position;
291  snprintf(indexBuffer, sizeof(indexBuffer), "W[%08lu]",pos); //build an index string for display purposes, p.e. W[15]
292 
293  return std::string(indexBuffer);
294 }
static int position[264][3]
Definition: ReadPGInfo.cc:509
DCCTBDataMapper * DCCTBDataParser::mapper ( )
inline
uint32_t DCCTBDataParser::numbSRF ( )
inline

Definition at line 185 of file DCCDataParser.h.

References parameters.

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

185 { return parameters[3]; }
std::vector< uint32_t > parameters
uint32_t DCCTBDataParser::numbTriggerSamples ( )
inline

Definition at line 183 of file DCCDataParser.h.

References parameters.

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

183 { return parameters[1]; }
std::vector< uint32_t > parameters
uint32_t DCCTBDataParser::numbTTs ( )
inline

Definition at line 184 of file DCCDataParser.h.

References parameters.

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

184 { return parameters[2]; }
std::vector< uint32_t > parameters
uint32_t DCCTBDataParser::numbXtalSamples ( )
inline

Definition at line 182 of file DCCDataParser.h.

References parameters.

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

182 { return parameters[0]; }
std::vector< uint32_t > parameters
void DCCTBDataParser::parseBuffer ( uint32_t *  buffer,
uint32_t  bufferSize,
bool  singleEvent = false 
)

Parse data from a buffer

Definition at line 114 of file DCCDataParser.cc.

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

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

114  {
115 
116  resetErrorCounters(); //reset error counters
117 
118  buffer_ = buffer; //set class buffer
119 
120  //clear stored data
121  processedEvent_ = 0;
122  events_.clear();
123  std::vector<DCCTBEventBlock *>::iterator it;
124  for( it = dccEvents_.begin(); it!=dccEvents_.end(); it++ ) { delete *it; }
125  dccEvents_.clear();
126  eventErrors_ = "";
127 
128  //for debug purposes
129  //std::cout << std::endl << "Now in DCCTBDataParser::parseBuffer" << std::endl;
130  //std::cout << std::endl << "Buffer Size:" << dec << bufferSize << std::endl;
131 
132  //check if we have a coherent buffer size
133  if( bufferSize%8 ){
134  std::string fatalError ;
135  fatalError += "\n ======================================================================";
136  fatalError += "\n Fatal error at event = " + getDecString(events_.size()+1);
137  fatalError += "\n Buffer Size of = "+ getDecString(bufferSize) + "[bytes] is not divisible by 8 ... ";
138  fatalError += "\n ======================================================================";
139  throw ECALTBParserException(fatalError);
140  }
141  if ( bufferSize < EMPTYEVENTSIZE ){
142  std::string fatalError ;
143  fatalError += "\n ======================================================================";
144  fatalError += "\n Fatal error at event = " + getDecString(events_.size()+1);
145  fatalError += "\n Buffer Size of = "+ getDecString(bufferSize) + "[bytes] is less than an empty event ... ";
146  fatalError += "\n ======================================================================";
147  throw ECALTBParserException(fatalError);
148  }
149 
150  uint32_t *myPointer = buffer_;
151 
152  // uint32_t processedBytes(0), wordIndex(0), lastEvIndex(0),eventSize(0), eventLength(0), errorMask(0);
153  uint32_t processedBytes(0), wordIndex(0), eventLength(0), errorMask(0);
154 
155  //parse until there are no more events
156  while( processedBytes + EMPTYEVENTSIZE <= bufferSize ){
157 
158  //for debug purposes
159  //std::cout << "-> processedBytes. = " << dec << processedBytes << std::endl;
160  //std::cout << " -> Processed Event index = " << dec << processedEvent_ << std::endl;
161  //std::cout << "-> First ev.word = 0x" << hex << (*myPointer) << std::endl;
162  //std::cout << "-> word index = " << dec << wordIndex << std::endl;
163 
164  //check if Event Length is coherent /////////////////////////////////////////
165  uint32_t bytesToEnd = bufferSize - processedBytes;
166  std::pair<uint32_t,uint32_t> eventD = checkEventLength(myPointer,bytesToEnd,singleEvent);
167  eventLength = eventD.second;
168  errorMask = eventD.first;
170 
171  //for debug purposes
172  //std::cout <<" -> EventSizeBytes = " << dec << eventLength*8 << std::endl;
173 
174 
175 
176  //for debug purposes debug
177  //std::cout<<std::endl;
178  //std::cout<<" out... Bytes To End.... = "<<dec<<bytesToEnd<<std::endl;
179  //std::cout<<" out... Processed Event = "<<dec<<processedEvent_<<std::endl;
180  //std::cout<<" out... Event Length = "<<dec<<eventLength<<std::endl;
181  //std::cout<<" out... LastWord = 0x"<<hex<<*(myPointer+eventLength*2-1)<<std::endl;
182 
183  if (parseInternalData_){
184  //build a new event block from buffer
185  DCCTBEventBlock *myBlock = new DCCTBEventBlock(this,myPointer,eventLength*8, eventLength*2 -1 ,wordIndex,0);
186 
187  //add event to dccEvents vector
188  dccEvents_.push_back(myBlock);
189  }
190 
191  //build the event pointer with error mask and add it to the events vector
192  std::pair<uint32_t *, uint32_t> eventPointer(myPointer,eventLength);
193  std::pair<uint32_t, std::pair<uint32_t*, uint32_t> > eventPointerWithErrorMask(errorMask,eventPointer);
194  events_.push_back(eventPointerWithErrorMask);
195 
196  //update processed buffer size
197  processedEvent_++;
198  processedBytes += eventLength*8;
199  //std::cout << std::endl << "Processed Bytes = " << dec << processedBytes << std::endl;
200 
201  //go to next event
202  myPointer += eventLength*2;
203  wordIndex += eventLength*2;
204  }
205 }
std::vector< DCCTBEventBlock * > dccEvents_
void resetErrorCounters()
std::string getDecString(uint32_t data)
std::vector< std::pair< uint32_t, std::pair< uint32_t *, uint32_t > > > events_
std::pair< uint32_t, uint32_t > checkEventLength(uint32_t *pointerToEvent, uint32_t bytesToEnd, bool singleEvent=false)
uint32_t processedEvent_
std::string eventErrors_
uint32_t * buffer_
void DCCTBDataParser::parseFile ( std::string  fileName,
bool  singleEvent = false 
)

Parse data from file

Definition at line 61 of file DCCDataParser.cc.

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

61  {
62 
63  std::ifstream inputFile; //open file as input
64  inputFile.open(fileName.c_str());
65 
66  resetErrorCounters(); //reset error counters
67 
68  //for debug purposes
69  //std::cout << "Now in DCCTBDataParser::parseFile " << std::endl;
70 
71 
72  //if file opened correctly read data to a buffer and parse it
73  //else throw an exception
74  if( !inputFile.fail() ){
75 
76  std::string myWord; //word read from line
77  std::vector<std::string> dataVector; //data vector
78 
79  //until the end of file read each line as a string and add it to the data vector
80  while( inputFile >> myWord ){
81  dataVector.push_back( myWord );
82  }
83 
84  bufferSize_ = (dataVector.size() ) * 4 ; //buffer size in bytes (note:each char is an hex number)
85  if( buffer_ ){ delete [] buffer_; } //delete current vector if any
86  buffer_ = new uint32_t[dataVector.size()]; //allocate memory for new data buffer
87 
88  uint32_t *myData_ = (uint32_t *) buffer_;
89 
90  //fill buffer data with data from file lines
91  for(uint32_t i = 1; i <= dataVector.size() ; i++, myData_++ ){
92  sscanf((dataVector[i-1]).c_str(),"%x",(unsigned int *)myData_);
93 
94  //for debug purposes
95  //std::cout << std::endl << "Data position: " << dec << i << " val = " << getHexString(*myData_);
96  }
97 
98  inputFile.close(); //close file
99 
100  parseBuffer( buffer_,bufferSize_,singleEvent); //parse data from buffer
101 
102  }
103  else{
104  std::string errorMessage = std::string(" Error::Unable to open file :") + fileName;
105  throw ECALTBParserException(errorMessage);
106  }
107 }
void resetErrorCounters()
void parseBuffer(uint32_t *buffer, uint32_t bufferSize, bool singleEvent=false)
uint32_t bufferSize_
uint32_t * buffer_
std::vector< uint32_t > DCCTBDataParser::parserParameters ( )
inline

Get methods for parser parameters;

Definition at line 181 of file DCCDataParser.h.

References parameters.

181 { return parameters; }
std::vector< uint32_t > parameters
void DCCTBDataParser::resetErrorCounters ( )

Reset Error Counters

Definition at line 23 of file DCCDataParser.cc.

References errors_.

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

23  {
24  //set error counters to 0
25  errors_["DCC::BOE"] = 0; //begin of event (header B[60-63])
26  errors_["DCC::EOE"] = 0; //end of event (trailer B[60-63])
27  errors_["DCC::EVENT LENGTH"] = 0; //event length (trailer B[32-55])
28 }
std::map< std::string, uint32_t > errors_
void DCCTBDataParser::setParameters ( const std::vector< uint32_t > &  newParameters)
inline

Set method for parser parameters

Definition at line 193 of file DCCDataParser.h.

References computeBlockSizes(), and parameters.

193 { parameters = newParameters; computeBlockSizes();}
void computeBlockSizes()
std::vector< uint32_t > parameters
uint32_t DCCTBDataParser::srpBlockSize ( )
inline

Get methods for block sizes

Definition at line 195 of file DCCDataParser.h.

References srpBlockSize_.

Referenced by DCCTBEventBlock::DCCTBEventBlock().

195 { return srpBlockSize_; }
uint32_t srpBlockSize_
uint32_t DCCTBDataParser::srpId ( )
inline

Definition at line 187 of file DCCDataParser.h.

References parameters.

Referenced by DCCTBSRPBlock::dataCheck().

187 { return parameters[5]; }
std::vector< uint32_t > parameters
uint32_t DCCTBDataParser::tcc1Id ( )
inline

Definition at line 188 of file DCCDataParser.h.

References parameters.

Referenced by DCCTBEventBlock::DCCTBEventBlock().

188 { return parameters[6]; }
std::vector< uint32_t > parameters
uint32_t DCCTBDataParser::tcc2Id ( )
inline

Definition at line 189 of file DCCDataParser.h.

References parameters.

Referenced by DCCTBEventBlock::DCCTBEventBlock().

189 { return parameters[7]; }
std::vector< uint32_t > parameters
uint32_t DCCTBDataParser::tcc3Id ( )
inline

Definition at line 190 of file DCCDataParser.h.

References parameters.

Referenced by DCCTBEventBlock::DCCTBEventBlock().

190 { return parameters[8]; }
std::vector< uint32_t > parameters
uint32_t DCCTBDataParser::tcc4Id ( )
inline

Definition at line 191 of file DCCDataParser.h.

References parameters.

Referenced by DCCTBEventBlock::DCCTBEventBlock().

191 { return parameters[9]; }
std::vector< uint32_t > parameters
uint32_t DCCTBDataParser::tccBlockSize ( )
inline

Definition at line 196 of file DCCDataParser.h.

References tccBlockSize_.

Referenced by DCCTBEventBlock::DCCTBEventBlock().

196 { return tccBlockSize_; }
uint32_t tccBlockSize_

Member Data Documentation

uint32_t* DCCTBDataParser::buffer_
protected

Definition at line 145 of file DCCDataParser.h.

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

uint32_t DCCTBDataParser::bufferSize_
protected

Definition at line 146 of file DCCDataParser.h.

Referenced by parseFile().

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

Definition at line 155 of file DCCDataParser.h.

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

bool DCCTBDataParser::debug_
protected

Definition at line 161 of file DCCDataParser.h.

Referenced by debug().

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

Definition at line 162 of file DCCDataParser.h.

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

std::string DCCTBDataParser::eventErrors_
protected

Definition at line 152 of file DCCDataParser.h.

Referenced by parseBuffer().

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

Definition at line 158 of file DCCDataParser.h.

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

DCCTBDataMapper* DCCTBDataParser::mapper_
protected

Definition at line 153 of file DCCDataParser.h.

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

std::vector<uint32_t> DCCTBDataParser::parameters
protected
bool DCCTBDataParser::parseInternalData_
protected

Definition at line 160 of file DCCDataParser.h.

Referenced by parseBuffer().

uint32_t DCCTBDataParser::processedEvent_
protected

Definition at line 151 of file DCCDataParser.h.

Referenced by parseBuffer().

uint32_t DCCTBDataParser::srpBlockSize_
protected

Definition at line 148 of file DCCDataParser.h.

Referenced by computeBlockSizes(), and srpBlockSize().

uint32_t DCCTBDataParser::tccBlockSize_
protected

Definition at line 149 of file DCCDataParser.h.

Referenced by computeBlockSizes(), and tccBlockSize().