CMS 3D CMS Logo

DCCTBDataParser Class Reference

#include <EventFilter/EcalTBRawToDigi/src/DCCDataParser.h>

List of all members.

Public Types

enum  DCCDataParserGlobalFields { EMPTYEVENTSIZE = 32 }

Public Member Functions

std::pair< ulong, ulong > checkEventLength (ulong *pointerToEvent, ulong 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.
std::vector< DCCTBEventBlock * > & dccEvents ()
 Get method for DCCEventBlocks vector.
ulong dccId ()
 DCCTBDataParser (std::vector< ulong > 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.
bool debug ()
 Get methods for debug flag.
std::map< std::string, ulong > & errorCounters ()
 Get method for error counters map.
std::vector< std::pair< ulong,
std::pair< ulong *, ulong > > > 		events ()
 Get method for events.
ulong * getBuffer ()
 Retrieves a pointer to the data buffer.
std::string getDecString (ulong data)
 Methods to get data strings formatted as decimal/hexadecimal, indexes and indexed data.
std::string getHexString (ulong data)
std::string getIndexedData (ulong indexed, ulong *pointer)
std::string index (ulong position)
DCCTBDataMapper * mapper ()
 Get method for DCCTBDataMapper.
ulong numbSRF ()
ulong numbTriggerSamples ()
ulong numbTTs ()
ulong numbXtalSamples ()
void parseBuffer (ulong *buffer, ulong bufferSize, bool singleEvent=false)
 Parse data from a buffer.
void parseFile (std::string fileName, bool singleEvent=false)
 Parse data from file.
std::vector< ulong > parserParameters ()
 Get methods for parser parameters;.
void resetErrorCounters ()
 Reset Error Counters.
void setParameters (std::vector< ulong > newParameters)
 Set method for parser parameters.
ulong srpBlockSize ()
 Get methods for block sizes.
ulong srpId ()
ulong tcc1Id ()
ulong tcc2Id ()
ulong tcc3Id ()
ulong tcc4Id ()
ulong tccBlockSize ()
 ~DCCTBDataParser ()
 Class destructor.

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

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

Detailed Description

Definition at line 27 of file DCCDataParser.h.

Member Enumeration Documentation

enum DCCTBDataParser::DCCDataParserGlobalFields

Enumerator:
EMPTYEVENTSIZE 

Definition at line 138 of file DCCDataParser.h.

00138                                 {
00139     EMPTYEVENTSIZE = 32                   //bytes
00140   };

enum DCCTBDataParser::DCCTBDataParserFields [protected]

Enumerator:
EVENTLENGTHMASK 
BOEBEGIN 
BOEMASK 
BOE 
EOEBEGIN 
EOEMASK 
EOE 

Definition at line 165 of file DCCDataParser.h.

00165                             {
00166     EVENTLENGTHMASK = 0xFFFFFF,
00167     
00168     BOEBEGIN = 28,                  //begin of event (on 32 bit string starts at bit 28)
00169     BOEMASK = 0xF,                  //mask is 4 bits (F)
00170     BOE =0x5,                       //B'0101'
00171 
00172     EOEBEGIN = 28,                  //end of event
00173     EOEMASK = 0xF,                  //4 bits
00174     EOE =0xA                        //B'1010'
00175   };

Constructor & Destructor Documentation

DCCTBDataParser::DCCTBDataParser ( std::vector< ulong >  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().

00009                                                                                                     :
00010   buffer_(0),parseInternalData_(parseInternalData),debug_(debug), parameters(parserParameters){
00011         
00012   mapper_ = new DCCTBDataMapper(this);       //build a new data mapper
00013   resetErrorCounters();                    //restart error counters
00014   computeBlockSizes();                     //calculate block sizes
00015   
00016 }

DCCTBDataParser::~DCCTBDataParser (  ) 

Class destructor.

Definition at line 345 of file DCCDataParser.cc.

References dccEvents_, it, and mapper_.

00345                                  {
00346   
00347   // delete DCCTBEvents if any...
00348   std::vector<DCCTBEventBlock *>::iterator it;
00349   for(it=dccEvents_.begin();it!=dccEvents_.end();it++){delete *it;}
00350   dccEvents_.clear();
00351     
00352   delete mapper_;
00353 }

Member Function Documentation

std::pair< ulong, ulong > DCCTBDataParser::checkEventLength ( ulong *  pointerToEvent,
ulong  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(), and HLT_VtxMuL3::result.

Referenced by parseBuffer().

00218                                                                                                                {
00219         
00220   std::pair<ulong,ulong> result;    //returns error mask and event length 
00221   ulong errorMask(0);          //error mask to return
00222 
00223   //check begin of event (BOE bits field) 
00224   //(Note: we have to add one to read the 2nd 32 bit word where BOE is written)
00225   ulong *boePointer = pointerToEvent + 1;
00226   if( ((*boePointer)>>BOEBEGIN)& BOEMASK != BOE ) { 
00227     (errors_["DCC::BOE"])++; errorMask = 1; 
00228   }
00229         
00230         
00231   //get Event Length from buffer (Note: we have to add two to read the 3rd 32 bit word where EVENT LENGTH is written)
00232   ulong * myPointer = pointerToEvent + 2; 
00233   ulong eventLength = (*myPointer)&EVENTLENGTHMASK;
00234 
00235   // cout << " Event Length(from decoding) = " << dec << eventLength << "... bytes to end... " << bytesToEnd << ", event numb : " << processedEvent_ << endl;
00236   
00237   bool eoeError = false;
00238 
00239   //check if event is empty but but EVENT LENGTH is not corresponding to it
00240   if( singleEvent && eventLength != bytesToEnd/8 ){
00241     eventLength = bytesToEnd/8;
00242     (errors_["DCC::EVENT LENGTH"])++; 
00243     errorMask = errorMask | (1<<1);
00244   }
00245   //check if event length mismatches the number of words written as data
00246   else if( eventLength == 0 || eventLength > (bytesToEnd / 8) || eventLength < (EMPTYEVENTSIZE/8) ){  
00247     // How to handle bad event length in multiple event buffers
00248     // First approach : Send an exception       
00249     // Second aproach : Try to find the EOE (To be done? If yes check dataDecoder tBeam implementation)
00250     std::string fatalError;
00251                 
00252     fatalError +="\n ======================================================================";           
00253     fatalError +="\n Fatal error at event = " + getDecString(events_.size()+1);
00254     fatalError +="\n Decoded event length = " + getDecString(eventLength);
00255     fatalError +="\n bytes to buffer end  = " + getDecString(bytesToEnd);
00256     fatalError +="\n Unable to procead the data decoding ...";
00257 
00258     if(eventLength > (bytesToEnd / 8)){ fatalError +=" (eventLength > (bytesToEnd / 8)";}
00259     else{ fatalError += "\n event length not big enough heaven to build an empty event ( 4x8 bytes)";}
00260 
00261     fatalError +="\n ======================================================================";
00262 
00263     throw ECALTBParserException(fatalError);
00264   }
00265 
00266   //check end of event (EOE bits field) 
00267   //(Note: event length is multiplied by 2 because its written as 32 bit words and not 64 bit words)
00268   ulong *endOfEventPointer = pointerToEvent + eventLength*2 -1;
00269   if (((*endOfEventPointer) >> EOEBEGIN & EOEMASK != EOEMASK) && !eoeError ){ 
00270     (errors_["DCC::EOE"])++; 
00271     errorMask = errorMask | (1<<2); 
00272   }
00273   
00274   //build result to return
00275   result.first  = errorMask;
00276   result.second = eventLength;
00277   
00278   return result;
00279 }

void DCCTBDataParser::computeBlockSizes (  )  [protected]

Definition at line 35 of file DCCDataParser.cc.

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

Referenced by DCCTBDataParser(), and setParameters().

00035                                        {
00036   ulong nTT = numbTTs();                                      //gets the number of the trigger towers (default:68)  
00037   ulong tSamples = numbTriggerSamples();                      //gets the number of trigger time samples (default: 1)
00038   ulong nSr = numbSRF();                                      //gests the number of SR flags (default:68)
00039 
00040   ulong tf(0), srf(0);
00041         
00042   if( (nTT*tSamples)<4 || (nTT*tSamples)%4 ) tf=1;            //test is there is no TTC primitives or if it's a multiple of 4?
00043   else tf=0;
00044   
00045 
00046   if( srf<16 || srf%16 ) srf=1;                               //??? by default srf=0 why do we make this test ?????
00047   else srf=0;
00048   
00049   //TTC block size: header (8 bytes) + 17 words with 4 trigger primitives (17*8bytes)
00050   tccBlockSize_ = 8 + ((nTT*tSamples)/4)*8 + tf*8 ;          
00051 
00052   //SR block size: header (8 bytes) + 4 words with 16 SR flags + 1 word with 4 SR flags (5*8bytes)
00053   srpBlockSize_ = 8 + (nSr/16)*8 + srf*8;
00054 }

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().

00199 { return dccEvents_;    }

ulong DCCTBDataParser::dccId (  )  [inline]

Definition at line 186 of file DCCDataParser.h.

References parameters.

00186 { return parameters[4]; }

bool DCCTBDataParser::debug (  )  [inline]

Get methods for debug flag.

Definition at line 198 of file DCCDataParser.h.

References debug_.

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

00198 { return debug_;     }

std::map< std::string, ulong > & DCCTBDataParser::errorCounters (  )  [inline]

Get method for error counters map.

Definition at line 200 of file DCCDataParser.h.

References errors_.

00200 { return errors_;       }

std::vector< std::pair< ulong, std::pair< ulong *, ulong > > > DCCTBDataParser::events (  )  [inline]

Get method for events.

Definition at line 201 of file DCCDataParser.h.

References events_.

00201 { return events_;   }

ulong* DCCTBDataParser::getBuffer (  )  [inline]

Retrieves a pointer to the data buffer.

Definition at line 131 of file DCCDataParser.h.

References buffer_.

00131 { return buffer_;}

std::string DCCTBDataParser::getDecString ( ulong  data  ) 

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

Definition at line 300 of file DCCDataParser.cc.

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

00300                                                  {
00301         
00302   char buffer[10];
00303   sprintf(buffer,"%lu",data);
00304 
00305   return std::string(buffer);   
00306 }

std::string DCCTBDataParser::getHexString ( ulong  data  ) 

Definition at line 313 of file DCCDataParser.cc.

Referenced by getIndexedData().

00313                                                  {
00314         
00315   char buffer[10];
00316   sprintf(buffer,"0x%08x",(uint)(data));
00317 
00318   return std::string(buffer);   
00319 }

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

Definition at line 326 of file DCCDataParser.cc.

References getHexString(), and index().

00326                                                                        {
00327   std::string ret;
00328   
00329   //char indexBuffer[20];
00330   //char dataBuffer[20];
00331   //sprintf(indexBuffer,"W[%08u] = ",position);
00332   //sprintf(dataBuffer,"0x%08x",*pointer);
00333   //ret = std::string(indexBuffer)+std::string(dataBuffer);
00334 
00335   ret = index(position) + getHexString(*pointer);
00336   
00337   return ret;   
00338 }

std::string DCCTBDataParser::index ( ulong  position  ) 

Definition at line 287 of file DCCDataParser.cc.

Referenced by getIndexedData().

00287                                               {
00288 
00289   char indexBuffer[20];
00290   sprintf(indexBuffer,"W[%08lu]",position);        //build an index string for display purposes, p.e.  W[15] 
00291 
00292   return std::string(indexBuffer);      
00293 }

DCCTBDataMapper * DCCTBDataParser::mapper (  )  [inline]

Get method for DCCTBDataMapper.

Definition at line 179 of file DCCDataParser.h.

References mapper_.

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

00179 { return mapper_;}

ulong DCCTBDataParser::numbSRF (  )  [inline]

Definition at line 185 of file DCCDataParser.h.

References parameters.

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

00185 { return parameters[3]; }

ulong DCCTBDataParser::numbTriggerSamples (  )  [inline]

Definition at line 183 of file DCCDataParser.h.

References parameters.

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

00183 { return parameters[1]; }

ulong DCCTBDataParser::numbTTs (  )  [inline]

Definition at line 184 of file DCCDataParser.h.

References parameters.

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

00184 { return parameters[2]; }

ulong DCCTBDataParser::numbXtalSamples (  )  [inline]

Definition at line 182 of file DCCDataParser.h.

References parameters.

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

00182 { return parameters[0]; }

void DCCTBDataParser::parseBuffer ( ulong *  buffer,
ulong  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(), it, parseInternalData_, processedEvent_, and resetErrorCounters().

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

00114                                                                                    {
00115         
00116   resetErrorCounters();                           //reset error counters
00117         
00118   buffer_ = buffer;                               //set class buffer
00119   
00120   //clear stored data
00121   processedEvent_ = 0;
00122   events_.clear();
00123   std::vector<DCCTBEventBlock *>::iterator it;
00124   for( it = dccEvents_.begin(); it!=dccEvents_.end(); it++ ) { delete *it; }
00125   dccEvents_.clear();
00126   eventErrors_ = "";
00127         
00128   //for debug purposes
00129   //cout << endl << "Now in DCCTBDataParser::parseBuffer" << endl;
00130   //cout << endl << "Buffer Size:" << dec << bufferSize << endl;
00131         
00132   //check if we have a coherent buffer size
00133   if( bufferSize%8  ){
00134     std::string fatalError ;
00135     fatalError += "\n ======================================================================";          
00136     fatalError += "\n Fatal error at event = " + getDecString(events_.size()+1);
00137     fatalError += "\n Buffer Size of = "+ getDecString(bufferSize) + "[bytes] is not divisible by 8 ... ";
00138     fatalError += "\n ======================================================================";
00139     throw ECALTBParserException(fatalError);
00140   }
00141   if ( bufferSize < EMPTYEVENTSIZE ){
00142     std::string fatalError ;
00143     fatalError += "\n ======================================================================";          
00144     fatalError += "\n Fatal error at event = " + getDecString(events_.size()+1);
00145     fatalError += "\n Buffer Size of = "+ getDecString(bufferSize) + "[bytes] is less than an empty event ... ";
00146     fatalError += "\n ======================================================================";
00147     throw ECALTBParserException(fatalError);
00148   }
00149 
00150   ulong *myPointer =  buffer_;                        
00151   
00152   //  ulong processedBytes(0), wordIndex(0), lastEvIndex(0),eventSize(0), eventLength(0), errorMask(0);
00153   ulong processedBytes(0), wordIndex(0), eventLength(0), errorMask(0);
00154   
00155   //parse until there are no more events
00156   while( processedBytes + EMPTYEVENTSIZE <= bufferSize ){
00157 
00158     //for debug purposes
00159     //cout << "-> processedBytes.  =   " << dec << processedBytes << endl;
00160     //cout << " -> Processed Event index =   " << dec << processedEvent_ << endl;
00161     //cout << "-> First ev.word    = 0x" << hex << (*myPointer) << endl;
00162     //cout << "-> word index       =   " << dec << wordIndex << endl;
00163     
00164     //check if Event Length is coherent /////////////////////////////////////////
00165     ulong bytesToEnd         = bufferSize - processedBytes;
00166     std::pair<ulong,ulong> eventD = checkEventLength(myPointer,bytesToEnd,singleEvent);
00167     eventLength              = eventD.second; 
00168     errorMask                = eventD.first;
00170      
00171     //for debug purposes
00172     //cout <<" -> EventSizeBytes        =   " << dec << eventLength*8 << endl;
00173    
00174           
00175              
00176     //for debug purposes debug 
00177     //cout<<endl;
00178     //cout<<" out... Bytes To End.... =   "<<dec<<bytesToEnd<<endl;
00179     //cout<<" out... Processed Event  =   "<<dec<<processedEvent_<<endl;        
00180     //cout<<" out... Event Length     =   "<<dec<<eventLength<<endl;
00181     //cout<<" out... LastWord         = 0x"<<hex<<*(myPointer+eventLength*2-1)<<endl;
00182     
00183     if (parseInternalData_){ 
00184       //build a new event block from buffer
00185       DCCTBEventBlock *myBlock = new DCCTBEventBlock(this,myPointer,eventLength*8, eventLength*2 -1 ,wordIndex,0);
00186       
00187       //add event to dccEvents vector
00188       dccEvents_.push_back(myBlock);
00189     }
00190     
00191     //build the event pointer with error mask and add it to the events vector
00192     std::pair<ulong *, ulong> eventPointer(myPointer,eventLength);
00193     std::pair<ulong, std::pair<ulong*, ulong> > eventPointerWithErrorMask(errorMask,eventPointer);
00194     events_.push_back(eventPointerWithErrorMask);
00195                 
00196     //update processed buffer size 
00197     processedEvent_++;
00198     processedBytes += eventLength*8;
00199     //cout << endl << "Processed Bytes = " << dec << processedBytes << endl;
00200     
00201     //go to next event
00202     myPointer     += eventLength*2;
00203     wordIndex     += eventLength*2;
00204   } 
00205 }

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

Parse data from file.

Definition at line 61 of file DCCDataParser.cc.

References buffer_, bufferSize_, i, outputToXml::inputFile, parseBuffer(), and resetErrorCounters().

00061                                                                    {
00062         
00063   std::ifstream inputFile;                            //open file as input
00064   inputFile.open(fileName.c_str());
00065         
00066   resetErrorCounters();                          //reset error counters
00067 
00068   //for debug purposes
00069   //cout << "Now in DCCTBDataParser::parseFile " << endl;
00070 
00071         
00072   //if file opened correctly read data to a buffer and parse it
00073   //else throw an exception
00074   if( !inputFile.fail() ){ 
00075         
00076     std::string myWord;                               //word read from line
00077     std::vector<std::string> dataVector;                   //data vector
00078     
00079     //until the end of file read each line as a string and add it to the data vector
00080     while( inputFile >> myWord ){ 
00081       dataVector.push_back( myWord ); 
00082     }
00083     
00084     bufferSize_ = (dataVector.size() ) * 4 ;      //buffer size in bytes (note:each char is an hex number)
00085     if( buffer_ ){ delete [] buffer_; }           //delete current vector if any
00086     buffer_ = new ulong[dataVector.size()];       //allocate memory for new data buffer
00087 
00088     ulong *myData_ = (ulong *) buffer_;         
00089     
00090     //fill buffer data with data from file lines
00091     for(ulong i = 1; i <= dataVector.size() ; i++, myData_++ ){
00092       sscanf((dataVector[i-1]).c_str(),"%x",(uint *)myData_);
00093       
00094       //for debug purposes
00095       //cout << endl << "Data position: " << dec << i << " val = " << getHexString(*myData_);
00096     }
00097     
00098     inputFile.close();                              //close file
00099     
00100     parseBuffer( buffer_,bufferSize_,singleEvent);  //parse data from buffer
00101     
00102   }
00103   else{ 
00104     std::string errorMessage = std::string(" Error::Unable to open file :") + fileName;
00105     throw ECALTBParserException(errorMessage);
00106   }
00107 }

std::vector< ulong > DCCTBDataParser::parserParameters (  )  [inline]

Get methods for parser parameters;.

Definition at line 181 of file DCCDataParser.h.

References parameters.

00181 { return parameters; }

void DCCTBDataParser::resetErrorCounters (  ) 

Reset Error Counters.

Definition at line 23 of file DCCDataParser.cc.

References errors_.

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

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

void DCCTBDataParser::setParameters ( std::vector< ulong >  newParameters  )  [inline]

Set method for parser parameters.

Definition at line 193 of file DCCDataParser.h.

References computeBlockSizes(), and parameters.

00193 { parameters = newParameters; computeBlockSizes();}

ulong DCCTBDataParser::srpBlockSize (  )  [inline]

Get methods for block sizes.

Definition at line 195 of file DCCDataParser.h.

References srpBlockSize_.

Referenced by DCCTBEventBlock::DCCTBEventBlock().

00195 { return srpBlockSize_; }

ulong DCCTBDataParser::srpId (  )  [inline]

Definition at line 187 of file DCCDataParser.h.

References parameters.

Referenced by DCCTBSRPBlock::dataCheck().

00187 { return parameters[5]; }

ulong DCCTBDataParser::tcc1Id (  )  [inline]

Definition at line 188 of file DCCDataParser.h.

References parameters.

Referenced by DCCTBEventBlock::DCCTBEventBlock().

00188 { return parameters[6]; }

ulong DCCTBDataParser::tcc2Id (  )  [inline]

Definition at line 189 of file DCCDataParser.h.

References parameters.

Referenced by DCCTBEventBlock::DCCTBEventBlock().

00189 { return parameters[7]; }

ulong DCCTBDataParser::tcc3Id (  )  [inline]

Definition at line 190 of file DCCDataParser.h.

References parameters.

Referenced by DCCTBEventBlock::DCCTBEventBlock().

00190 { return parameters[8]; }

ulong DCCTBDataParser::tcc4Id (  )  [inline]

Definition at line 191 of file DCCDataParser.h.

References parameters.

Referenced by DCCTBEventBlock::DCCTBEventBlock().

00191 { return parameters[9]; }

ulong DCCTBDataParser::tccBlockSize (  )  [inline]

Definition at line 196 of file DCCDataParser.h.

References tccBlockSize_.

Referenced by DCCTBEventBlock::DCCTBEventBlock().

00196 { return tccBlockSize_; }

Member Data Documentation

ulong* DCCTBDataParser::buffer_ [protected]

Definition at line 145 of file DCCDataParser.h.

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

ulong 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,ulong> 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< ulong, std::pair<ulong *, ulong> > > 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<ulong> DCCTBDataParser::parameters [protected]

Definition at line 163 of file DCCDataParser.h.

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

bool DCCTBDataParser::parseInternalData_ [protected]

Definition at line 160 of file DCCDataParser.h.

Referenced by parseBuffer().

ulong DCCTBDataParser::processedEvent_ [protected]

Definition at line 151 of file DCCDataParser.h.

Referenced by parseBuffer().

ulong DCCTBDataParser::srpBlockSize_ [protected]

Definition at line 148 of file DCCDataParser.h.

Referenced by computeBlockSizes(), and srpBlockSize().

ulong DCCTBDataParser::tccBlockSize_ [protected]

Definition at line 149 of file DCCDataParser.h.

Referenced by computeBlockSizes(), and tccBlockSize().

The documentation for this class was generated from the following files:
Generated on Tue Jun 9 18:17:42 2009 for CMSSW by  doxygen 1.5.4