#include <DCCEventBlock.h>

Inheritance diagram for DCCTBEventBlock:

Public Member Functions
std::pair< bool, std::string >	compare (DCCTBEventBlock *)

void	dataCheck ()

	DCCTBEventBlock (DCCTBDataParser parser, uint32_t buffer, uint32_t numbBytes, uint32_t wordsToEnd, uint32_t wordBufferOffset=0, uint32_t wordEventOffset=0)

void	displayEvent (std::ostream &os=std::cout)

std::string	eventErrorString ()

bool	eventHasErrors ()

DCCTBSRPBlock *	srpBlock ()

std::vector< DCCTBTCCBlock * > &	tccBlocks ()

std::vector< DCCTBTowerBlock * > &	towerBlocks ()

std::vector< DCCTBTowerBlock * >	towerBlocksById (uint32_t towerId)

DCCTBTrailerBlock *	trailerBlock ()

	~DCCTBEventBlock ()

Public Member Functions inherited from DCCTBBlockPrototype
bool	blockError ()

virtual std::pair< bool, std::string >	checkDataField (std::string name, uint32_t data)

virtual std::pair< bool, std::string >	compare (DCCTBBlockPrototype *block)

	DCCTBBlockPrototype (DCCTBDataParser parser, std::string name, uint32_t buffer, uint32_t numbBytes, uint32_t wordsToEndOfEvent, uint32_t wordEventOffset=0)

virtual void	displayData (std::ostream &os=std::cout)

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

std::string &	errorString ()

virtual uint32_t	getDataField (std::string name)

virtual uint32_t	getDataWord (uint32_t wordPosition, uint32_t bitPosition, uint32_t mask)

DCCTBDataParser *	getParser ()

virtual void	increment (uint32_t numb, std::string msg="")

std::string	name ()

virtual void	parseData ()

virtual void	seeIfIsPossibleToIncrement (uint32_t numb, std::string msg="")

virtual void	setDataField (std::string name, uint32_t data)

uint32_t	size ()

uint32_t	wOffset ()

virtual	~DCCTBBlockPrototype ()

Protected Types
enum	dccFields { PHYSICTRIGGER = 1, CALIBRATIONTRIGGER = 2, TESTTRIGGER = 3, TECHNICALTRIGGER = 4, CH_ENABLED = 0, CH_DISABLED = 1, CH_TIMEOUT = 2, CH_SUPPRESS = 7, SR_NREAD = 0, BOE = 0x5, DCCERROR_EMPTYEVENT = 0x1, TOWERHEADER_SIZE = 8, TRAILER_SIZE = 8 }

Protected Attributes
DCCTBTrailerBlock *	dccTrailerBlock_

bool	emptyEvent

DCCTBSRPBlock *	srpBlock_

std::vector< DCCTBTCCBlock * >	tccBlocks_

std::vector< DCCTBTowerBlock * >	towerBlocks_

uint32_t	wordBufferOffset_

Protected Attributes inherited from DCCTBBlockPrototype
uint32_t *	beginOfBuffer_

bool	blockError_

uint32_t	blockSize_

std::string	blockString_

std::map< std::string, uint32_t >	dataFields_

uint32_t *	dataP_

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

std::string	errorString_

std::set< DCCTBDataField , DCCTBDataFieldComparator >	mapperFields_

std::string	name_

DCCTBDataParser *	parser_

std::string	processingString_

uint32_t	wordCounter_

uint32_t	wordEventOffset_

uint32_t	wordsToEndOfEvent_

Additional Inherited Members
Protected Member Functions inherited from DCCTBBlockPrototype
std::string	formatString (std::string myString, uint32_t minPositions)

Detailed Description

Definition at line 17 of file DCCEventBlock.h.

Member Enumeration Documentation

enum DCCTBEventBlock::dccFields

protected

Enumerator
PHYSICTRIGGER
CALIBRATIONTRIGGER
TESTTRIGGER
TECHNICALTRIGGER
CH_ENABLED
CH_DISABLED
CH_TIMEOUT
CH_SUPPRESS
SR_NREAD
BOE
DCCERROR_EMPTYEVENT
TOWERHEADER_SIZE
TRAILER_SIZE

Definition at line 47 of file DCCEventBlock.h.

                       { 
             
             PHYSICTRIGGER        = 1,
             CALIBRATIONTRIGGER   = 2,
             TESTTRIGGER          = 3,
             TECHNICALTRIGGER     = 4,
             
             CH_ENABLED           = 0,
             CH_DISABLED          = 1,
             CH_TIMEOUT           = 2,
             CH_SUPPRESS          = 7,
             
             SR_NREAD              = 0,
             
         
             BOE                  = 0x5, 
             
             DCCERROR_EMPTYEVENT  = 0x1, 
             
             TOWERHEADER_SIZE     = 8, 
             TRAILER_SIZE         = 8
     
         
         };      

Constructor & Destructor Documentation

DCCTBEventBlock::DCCTBEventBlock	(	DCCTBDataParser *	parser,
		uint32_t *	buffer,
		uint32_t	numbBytes,
		uint32_t	wordsToEnd,
		uint32_t	wordBufferOffset = `0`,
		uint32_t	wordEventOffset = `0`
	)

Definition at line 15 of file DCCEventBlock.cc.

   : 
 DCCTBBlockPrototype(parser,"DCCHEADER", buffer, numbBytes,wordsToEnd)
 ,dccTrailerBlock_(0),srpBlock_(0),wordBufferOffset_(wordBufferOffset) {
     
     
     //Reset error counters ////
     errors_["DCC::HEADER"] = 0;
     errors_["DCC::EVENT LENGTH"] = 0;
     
     uint32_t wToEnd(0);
     
     try{ 
     
         // Get data fields from the mapper and retrieve data ///    
         if(numbBytes == DCCTBDataParser::EMPTYEVENTSIZE ){
             mapperFields_ = parser_->mapper()->emptyEventFields();
             emptyEvent = true;
         }else{
             mapperFields_ = parser_->mapper()->dccFields(); 
             emptyEvent = false;
         }
         
         try{ parseData(); }
         catch (ECALTBParserBlockException &e){/*ignore*/}
         
 
     
         // Check internal data //////////////
         if(parser_->debug()){ dataCheck(); }
     
     
         // Check if empty event was produced /////////////////////////////////////////////////////////////////
 
         if( !emptyEvent && getDataField("DCC ERRORS")!= DCCERROR_EMPTYEVENT ){
                     
             // Build the SRP block ////////////////////////////////////////////////////////////////////////////////////
         
             bool srp(false);
             uint32_t sr_ch = getDataField("SR_CHSTATUS");
             if( sr_ch!=CH_TIMEOUT  && sr_ch != CH_DISABLED ){           
                 
                 //Go to the begining of the block
                 increment(1," (while trying to create a SR Block !)");
                 wToEnd = numbBytes/4-wordCounter_-1;    
                 
                 // Build SRP Block //////////////////////////////////////////////////////////////////////
                 srpBlock_ = new DCCTBSRPBlock( this, parser_, dataP_, parser_->srpBlockSize(), wToEnd,wordCounter_);
         
                 increment((parser_->srpBlockSize())/4-1);
                 if(getDataField("SR")){ srp=true; }
             }   
             
 
 
             // Build TCC blocks ////////////////////////////////////////////////////////////////////////////////////////
             for(uint32_t i=1; i<=4;i++){
               uint32_t tcc_ch=0;  uint32_t  tccId=0;
                 if( i == 1){ tccId = parser_->tcc1Id();}
                 if( i == 2){ tccId = parser_->tcc2Id();}
                 if( i == 3){ tccId = parser_->tcc3Id();}    
                 if( i == 4){ tccId = parser_->tcc4Id();}
                 
                 std::string tcc = std::string("TCC_CHSTATUS#") + parser_->getDecString(i);  
                 tcc_ch = getDataField(tcc);
                 
                 if( tcc_ch != CH_TIMEOUT && tcc_ch != CH_DISABLED){  
                     
                     //std::cout<<"\n debug:Building TCC Block, channel enabled without errors"<<std::endl;
                     
                     // Go to the begining of the block
                     increment(1," (while trying to create a"+tcc+" Block !)");
                     
                     wToEnd = numbBytes/4-wordCounter_-1;    
                     //wToEnd or wordsToEnd ????????????????????????????????????????
                     
                 
                     
                     // Build TCC Block /////////////////////////////////////////////////////////////////////////////////
                     tccBlocks_.push_back(  new DCCTBTCCBlock( this, parser_, dataP_,parser_->tccBlockSize(), wToEnd,wordCounter_, tccId));
                     
                     increment((parser_->tccBlockSize())/4-1);
                 }
             }
             
             
             
             // Build channel data //////////////////////////////////////////////////////////////////////////////////////////////////////    
             // See number of channels that we need according to the trigger type //
             // TODO : WHEN IN LOCAL MODE WE SHOULD CHECK RUN TYPE
             uint32_t triggerType = getDataField("TRIGGER TYPE");            
             uint32_t numbChannels;
             if( triggerType == PHYSICTRIGGER )          { numbChannels = 68; }
             else if (triggerType == CALIBRATIONTRIGGER ){ numbChannels = 70; }
             // TODO :: implement other triggers
             else{
               std::string error = std::string("\n DCC::HEADER TRIGGER TYPE = ")+parser_->getDecString(triggerType)+std::string(" is not a valid type !");
                 ECALTBParserBlockException a(error);
                 throw a;
             }
             
             
             
 //          uint32_t chStatus;
             uint32_t srFlag;
             bool suppress(false);
             
             for( uint32_t i=1; i<=numbChannels; i++){
                 
               std::string chStatusId = std::string("FE_CHSTATUS#") + parser_->getDecString(i);
                 uint32_t chStatus = getDataField(chStatusId);
                 
                 // If srp is on, we need to check if channel was suppressed ////////////////////
                 if(srp){ 
                     srFlag   = srpBlock_->getDataField( std::string("SR#") + parser_->getDecString(i));
                     if(srFlag == SR_NREAD){ suppress = true; }
                     else{ suppress = false; }
                 }
                     
                  
                 if( chStatus != CH_TIMEOUT && chStatus != CH_DISABLED && !suppress && chStatus !=CH_SUPPRESS){
 
                     
                     //Go to the begining of the block ///////////////////////////////////////////////////////////////////////
                     increment(1," (while trying to create a TOWERHEADER Block for channel "+parser_->getDecString(i)+" !)" );
                     
                     
                     // Instantiate a new tower block//////////////////////////////////////////////////////////////////////////
                     wToEnd = numbBytes/4-wordCounter_-1;
                     DCCTBTowerBlock * towerBlock = new DCCTBTowerBlock(this,parser_,dataP_,TOWERHEADER_SIZE,wToEnd,wordCounter_,i); 
                     towerBlocks_.push_back (towerBlock);
                     towerBlock->parseXtalData();
                     
                     
                     //go to the end of the block ///////////////////////////////
                     increment((towerBlock->getDataField("BLOCK LENGTH"))*2 - 1);
                         
                 }
             }
             
 
             // go to the begining of the block ////////////////////////////////////////////////////////////////////         
             increment(1," (while trying to create a DCC TRAILER Block !)");
             wToEnd = numbBytes/4-wordCounter_-1;
             dccTrailerBlock_ = new DCCTBTrailerBlock(parser_,dataP_,TRAILER_SIZE,wToEnd,wordCounter_,blockSize_/8,0);
             
         }
     
     }catch( ECALTBParserException & e){}
     catch( ECALTBParserBlockException & e){
       // uint32_t nEv = (parser_->dccEvents()).size() +1;
       errorString_ += std::string(e.what());
       blockError_=true;
       //std::cout<<"cout"<<e.what();
     }
     
     
 
 } 

DCCTBEventBlock::~DCCTBEventBlock ( )

Definition at line 197 of file DCCEventBlock.cc.

References dccTrailerBlock_, srpBlock_, tccBlocks_, and towerBlocks_.

                                  {
     
     std::vector<DCCTBTCCBlock *>::iterator it1;
     for(it1=tccBlocks_.begin();it1!=tccBlocks_.end();it1++){ delete (*it1);}
     tccBlocks_.clear();
     
     std::vector<DCCTBTowerBlock *>::iterator it2;
     for(it2=towerBlocks_.begin();it2!=towerBlocks_.end();it2++){ delete (*it2);}
     towerBlocks_.clear();
     
     if(srpBlock_ !=        0 ) { delete srpBlock_;       }
     if(dccTrailerBlock_ != 0 ) { delete dccTrailerBlock_;}
     
 }

Member Function Documentation

std::pair< bool, std::string > DCCTBEventBlock::compare ( DCCTBEventBlock * block )

Definition at line 307 of file DCCEventBlock.cc.

References begin, DCCTBBlockPrototype::compare(), end, GenerateHcalLaserBadRunList::out, runTheMatrix::ret, srpBlock(), srpBlock_, tccBlocks(), tccBlocks_, groupFilesInBlocks::temp, towerBlocks(), towerBlocks_, and trailerBlock().

                                                                        {
     
     // DCC Header comparision /////////////////////////////// 
     std::pair<bool,std::string> ret(DCCTBBlockPrototype::compare(block));
     
       std::stringstream out;
     
     // Selective readout processor block comparision ////////////////////////////////////////////
     if( srpBlock_ && block->srpBlock() ){ 
         std::pair<bool,std::string> temp( srpBlock_->compare(block->srpBlock()));
         ret.first   = ret.first & temp.first;
         out<<temp.second; 
     }else if( !srpBlock_ && block->srpBlock() ){
         ret.first   = false;    
         out<<"\n ====================================================================="
            <<"\n ERROR SR block identified in the ORIGINAL BLOCK ... "
            <<"\n ... but the block is not present in the COMPARISION BLOCK !" 
            <<"\n =====================================================================";
     }else if( srpBlock_ && !(block->srpBlock()) ){
         ret.first   = false;    
         out<<"\n ====================================================================="
            <<"\n ERROR SR block identified in the COMPARISION BLOCK ... "
            <<"\n ... but the block is not present in the ORIGINAL BLOCK !" 
            <<"\n =====================================================================";
     }
     
     
     
     // TCC Blocks comparision ////////////////////////////////////////////////////////
     // check number of TCC blocks 
     int numbTccBlocks_a = tccBlocks_.size();
     int numbTccBlocks_b = block->tccBlocks().size();
     
     if( numbTccBlocks_a != numbTccBlocks_b ){
         ret.first = false;
         out<<"\n ====================================================================="
            <<"\n ERROR number of TCC blocks in the ORIGINAL BLOCK( ="<<numbTccBlocks_a<<" )"
            <<"\n and in the COMPARISION BLOCK( = "<<numbTccBlocks_b<<" is different !"
            <<"\n =====================================================================";
     }
     
     std::vector<DCCTBTCCBlock *>::iterator it1Tcc    = tccBlocks_.begin();
     std::vector<DCCTBTCCBlock *>::iterator it1TccEnd = tccBlocks_.end();
     std::vector<DCCTBTCCBlock *>::iterator it2Tcc    = block->tccBlocks().begin();
     std::vector<DCCTBTCCBlock *>::iterator it2TccEnd = block->tccBlocks().end();
     
     for( ; it1Tcc!=it1TccEnd && it2Tcc!=it2TccEnd; it1Tcc++, it2Tcc++){
         std::pair<bool,std::string> temp( (*it1Tcc)->compare( *it2Tcc ) );
         ret.first   = ret.first & temp.first;
         out<<temp.second; 
     }
     
     
     // FE Blocks comparision ////////////////////////////////////////////////////////
     // check number of FE blocks 
     int numbTowerBlocks_a = towerBlocks_.size();
     int numbTowerBlocks_b = block->towerBlocks().size();
     
     if( numbTowerBlocks_a != numbTowerBlocks_b ){
         ret.first = false;
         out<<"\n ====================================================================="
            <<"\n ERROR number of Tower blocks in the ORIGINAL BLOCK( ="<<numbTowerBlocks_a<<" )"
            <<"\n and in the COMPARISION BLOCK( = "<<numbTowerBlocks_b<<" is different !"
            <<"\n =====================================================================";
     }
     
     std::vector<DCCTBTowerBlock *>::iterator it1Tower    = towerBlocks_.begin();
     std::vector<DCCTBTowerBlock *>::iterator it1TowerEnd  = towerBlocks_.end();
     std::vector<DCCTBTowerBlock *>::iterator it2Tower    = (block->towerBlocks()).begin();
     std::vector<DCCTBTowerBlock *>::iterator it2TowerEnd = (block->towerBlocks()).end();
     
     for( ; it1Tower!=it1TowerEnd && it2Tower!=it2TowerEnd; it1Tower++, it2Tower++){
         
         std::pair<bool,std::string> temp( (*it1Tower)->compare( *it2Tower ) );
         ret.first   = ret.first & temp.first;
         out<<temp.second;
 
         // Xtal Block comparision ////////////////////////////
         std::vector<DCCTBXtalBlock *> xtalBlocks1( (*it1Tower)->xtalBlocks());
         std::vector<DCCTBXtalBlock *> xtalBlocks2( (*it2Tower)->xtalBlocks());
         // check number of xtal blocks 
         int numbXtalBlocks_a = xtalBlocks1.size();
         int numbXtalBlocks_b = xtalBlocks2.size();
     
         if( numbXtalBlocks_a != numbXtalBlocks_b ){
             ret.first = false;
             out<<"\n ====================================================================="
                <<"\n ERROR number of Xtal blocks in this TOWER ORIGINAL BLOCK( ="<<numbXtalBlocks_a<<" )"
                <<"\n and in the TOWER COMPARISION BLOCK( = "<<numbXtalBlocks_b<<" is different !"
                <<"\n =====================================================================";
         }
         
         std::vector<DCCTBXtalBlock *>::iterator it1Xtal    = xtalBlocks1.begin();
         std::vector<DCCTBXtalBlock *>::iterator it1XtalEnd = xtalBlocks1.end();
         std::vector<DCCTBXtalBlock *>::iterator it2Xtal    = xtalBlocks1.begin();
         std::vector<DCCTBXtalBlock *>::iterator it2XtalEnd = xtalBlocks2.end();
         
         for( ; it1Xtal!=it1XtalEnd && it2Xtal!=it2XtalEnd; it1Xtal++, it2Xtal++){
             std::pair<bool,std::string> temp( (*it1Xtal)->compare( *it2Xtal ) );
             ret.first   = ret.first & temp.first;
             out<<temp.second; 
         }
         
     }
     
     
     // Trailer block comparision ////////////////////////////////////////////
     if(  block->trailerBlock() && trailerBlock() ){ 
         std::pair<bool,std::string> temp( trailerBlock()->compare(block->trailerBlock()));
         ret.first   = ret.first & temp.first;
         out<<temp.second; 
     }
     
     ret.second += out.str(); 
 
     return ret;
 }

void DCCTBEventBlock::dataCheck ( )

Definition at line 214 of file DCCEventBlock.cc.

References DCCTBBlockPrototype::blockError_, DCCTBBlockPrototype::blockSize_, BOE, DCCTBBlockPrototype::checkDataField(), emptyEvent, DCCTBBlockPrototype::errors_, DCCTBBlockPrototype::errorString_, DCCTBDataParser::getDecString(), i, DCCTBBlockPrototype::name_, DCCTBBlockPrototype::parser_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by DCCTBEventBlock().

                                {
     
     
     std::string checkErrors("");
     
     
     // Check BOE field/////////////////////////////////////////////////////
     std::pair<bool,std::string> res =  checkDataField("BOE",BOE);
     if(!res.first){ checkErrors += res.second; (errors_["DCC::HEADER"])++; }
     
     
     // Check H Field //////////////////////////////////////////////////////
     std::string hField= std::string("H");
     res = checkDataField(hField,1);
     if(!res.first){ checkErrors += res.second; (errors_["DCC::HEADER"])++; }
     
     
     // Check Headers //////////////////////////////////////////////////////////
     uint32_t dccHeaderWords = 0;
     
     if(emptyEvent){ dccHeaderWords = 2;}
     else if(!emptyEvent){ dccHeaderWords = 7;}
 
     for(uint32_t i = 1; i<=dccHeaderWords ; i++){
 
         std::string header= std::string("H") + parser_->getDecString(i);
         res = checkDataField(header,i);
         if(!res.first){ checkErrors += res.second; (errors_["DCC::HEADER"])++; }
     }
     
     
     // Check event length ///////////////////////////////////////////////////////
     res = checkDataField("EVENT LENGTH",blockSize_/8);
     if(!res.first){ checkErrors += res.second; (errors_["DCC::EVENT LENGTH"])++; }
         
     
     if(checkErrors!=""){
         errorString_ +="\n ======================================================================\n";       
         errorString_ += std::string(" ") + name_ + std::string(" data fields checks errors : ") ;
         errorString_ += checkErrors ;
         errorString_ += "\n ======================================================================";
         blockError_ = true; 
     }
     
     
 }

void DCCTBEventBlock::displayEvent ( std::ostream & os = std::cout )

Definition at line 267 of file DCCEventBlock.cc.

References dccTrailerBlock_, TauDecayModes::dec, DCCTBBlockPrototype::displayData(), srpBlock_, tccBlocks_, towerBlocks_, and wordBufferOffset_.

                                                   {
 
   os << "\n\n\n\n\n >>>>>>>>>>>>>>>>>>>> Event started at word position " << std::dec << wordBufferOffset_ <<" <<<<<<<<<<<<<<<<<<<<"<<std::endl;
     
     // Display DCC Header ///
     displayData(os);
         
         
     // Display SRP Block Contents //////////////
     if(srpBlock_){ srpBlock_->displayData(os);}
         
         
     // Display TCC Block Contents ///////////////////////////////
     std::vector<DCCTBTCCBlock *>::iterator it1;
     for( it1 = tccBlocks_.begin(); it1!= tccBlocks_.end(); it1++){
         (*it1)->displayData(os);
     }
     
     // Display Towers Blocks /////////////////////////////////////
     std::vector<DCCTBTowerBlock *>::iterator it2;
     for(it2 = towerBlocks_.begin();it2!=towerBlocks_.end();it2++){
             
         (*it2)->displayData(os);
             
         // Display Xtal Data /////////////////////////////////////
         std::vector<DCCTBXtalBlock * > &xtalBlocks = (*it2)->xtalBlocks();
         std::vector<DCCTBXtalBlock * >::iterator it3;
         for(it3 = xtalBlocks.begin();it3!=xtalBlocks.end();it3++){
             (*it3)->displayData(os);
         }   
     }
         
     // Display Trailer Block Contents /////////////////////////
     if(dccTrailerBlock_){ dccTrailerBlock_->displayData(os);}
         
 }

std::string DCCTBEventBlock::eventErrorString ( )

Definition at line 481 of file DCCEventBlock.cc.

References dccTrailerBlock_, DCCTBBlockPrototype::errorString(), eventHasErrors(), DCCTBBlockPrototype::getDataField(), DCCTBDataParser::getDecString(), DCCTBBlockPrototype::parser_, runTheMatrix::ret, srpBlock_, AlCaHLTBitMon_QueryRunRegistry::string, tccBlocks_, groupFilesInBlocks::temp, and towerBlocks_.

                                            {
     
     std::string ret("");
     
     if( eventHasErrors() ){
         
         
         ret +="\n ======================================================================\n";        
         ret += std::string(" Event Erros occurred for L1A ( decoded value ) = ") ; 
         ret += parser_->getDecString(getDataField("LV1"));
         ret += "\n ======================================================================";
         
     
         ret += errorString();
     
         // TODO ::
         // See if we have errors in the  TCC Block Contents /////////////
         std::vector<DCCTBTCCBlock *>::iterator it1;
         for( it1 = tccBlocks_.begin(); it1!= tccBlocks_.end(); it1++){
             ret += (*it1)->errorString();
         }
         // See if we have errors in the SRP Block ////
          if(srpBlock_){  ret += srpBlock_->errorString(); }
     
     
         // See if we have errors in the Tower Blocks ///////////////////////////////////////////////////
         std::vector<DCCTBTowerBlock *>::iterator it2;
         
         for(it2 = towerBlocks_.begin();it2!=towerBlocks_.end();it2++){
             
             ret += (*it2)->errorString();
             
             // See if we have errors in the Xtal Data /////////////////
             std::vector<DCCTBXtalBlock * > & xtalBlocks = (*it2)->xtalBlocks();
             std::vector<DCCTBXtalBlock * >::iterator it3;
         
         
             std::string temp;
             for(it3 = xtalBlocks.begin();it3!=xtalBlocks.end();it3++){ temp += (*it3)->errorString();}
         
             if(temp!=""){
                 ret += "\n Fine grain data Errors found ...";
                 ret += "\n(  Tower ID = " + parser_->getDecString( (*it2)->getDataField("TT/SC ID"));
                 ret += ", LV1 = " + parser_->getDecString( (*it2)->getDataField("LV1"));
                 ret += ", BX = " + parser_->getDecString( (*it2)->getDataField("BX")) + " )";
                 ret += temp;
             }
             
         }
     
         
         // See if we have errors in the  trailler ////////////////////
         if(dccTrailerBlock_){ ret += dccTrailerBlock_->errorString();}
     
     }
     
     return ret;
     
 }

bool DCCTBEventBlock::eventHasErrors ( )

Definition at line 436 of file DCCEventBlock.cc.

References DCCTBBlockPrototype::blockError(), dccTrailerBlock_, runTheMatrix::ret, srpBlock_, tccBlocks_, and towerBlocks_.

Referenced by eventErrorString().

                                     {
     
     bool ret(false);
     ret = blockError() ;
     
 
     // See if we have errors in the  TCC Block Contents ///////////////////////////////
     std::vector<DCCTBTCCBlock *>::iterator it1;
     for( it1 = tccBlocks_.begin(); it1!= tccBlocks_.end(); it1++){
         ret |= (*it1)->blockError();
     }
 
     // See if we have errors in the SRP Block /////////
     if(srpBlock_){  ret |= srpBlock_->blockError(); }
 
     
     // See if we have errors in the Trigger Blocks ///////////////
     std::vector<DCCTBTowerBlock *>::iterator it2;
     for(it2 = towerBlocks_.begin();it2!=towerBlocks_.end();it2++){
             
         ret |= (*it2)->blockError();
             
         // See if we have errors in the Xtal Data /////////////////
         std::vector<DCCTBXtalBlock * > & xtalBlocks = (*it2)->xtalBlocks();
         std::vector<DCCTBXtalBlock * >::iterator it3;
         for(it3 = xtalBlocks.begin();it3!=xtalBlocks.end();it3++){
             ret |= (*it3)->blockError();
         }
     }
     
         
     // See if we have errors in the  trailler ///////////////////
     if(dccTrailerBlock_){ ret |= dccTrailerBlock_->blockError();}
     
     
     return ret;
     
 }

DCCTBSRPBlock * DCCTBEventBlock::srpBlock ( )

inline

Definition at line 83 of file DCCEventBlock.h.

References srpBlock_.

Referenced by compare().

83 { return srpBlock_; }

DCCTBEventBlock::srpBlock_

DCCTBSRPBlock * srpBlock_

Definition: DCCEventBlock.h:75

std::vector< DCCTBTCCBlock * > & DCCTBEventBlock::tccBlocks ( )

inline

Definition at line 82 of file DCCEventBlock.h.

References tccBlocks_.

Referenced by compare().

82 { return tccBlocks_; }

DCCTBEventBlock::tccBlocks_

std::vector< DCCTBTCCBlock * > tccBlocks_

Definition: DCCEventBlock.h:73

std::vector< DCCTBTowerBlock * > & DCCTBEventBlock::towerBlocks ( )

inline

Definition at line 81 of file DCCEventBlock.h.

References towerBlocks_.

Referenced by compare().

81 { return towerBlocks_; }

DCCTBEventBlock::towerBlocks_

std::vector< DCCTBTowerBlock * > towerBlocks_

Definition: DCCEventBlock.h:72

std::vector< DCCTBTowerBlock * > DCCTBEventBlock::towerBlocksById ( uint32_t towerId )

Definition at line 548 of file DCCEventBlock.cc.

References alignCSCRings::e, and towerBlocks_.

                                                                                {
     std::vector<DCCTBTowerBlock *> myVector;    
     std::vector<DCCTBTowerBlock *>::iterator it;
     
     for( it = towerBlocks_.begin(); it!= towerBlocks_.end(); it++ ){
         try{
             
             std::pair<bool,std::string> idCheck   = (*it)->checkDataField("TT/SC ID",towerId);
             
             if(idCheck.first ){ myVector.push_back( (*it) ); }
         }catch (ECALTBParserBlockException &e){/*ignore*/}
     }
     
     return myVector;
 }