DCCTBEventBlock Class Reference

#include <DCCEventBlock.h>

Inheritance diagram for DCCTBEventBlock:

Public Member Functions
std::pair< bool, std::string >	compare (DCCTBEventBlock *)
void	dataCheck ()
	DCCTBEventBlock (DCCTBDataParser *parser, const 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 () override
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, const 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
const uint32_t *	beginOfBuffer_
bool	blockError_
uint32_t	blockSize_
std::string	blockString_
std::map< std::string, uint32_t >	dataFields_
const 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 48 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,
		const 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.

References a, DCCTBBlockPrototype::blockError_, DCCTBBlockPrototype::blockSize_, CALIBRATIONTRIGGER, CH_DISABLED, CH_SUPPRESS, CH_TIMEOUT, dataCheck(), DCCTBBlockPrototype::dataP_, DCCERROR_EMPTYEVENT, DCCTBDataMapper::dccFields(), dccTrailerBlock_, DCCTBDataParser::debug(), MillePedeFileConverter_cfg::e, emptyEvent, DCCTBDataMapper::emptyEventFields(), DCCTBDataParser::EMPTYEVENTSIZE, relativeConstraints::error, DCCTBBlockPrototype::errors_, DCCTBBlockPrototype::errorString_, DCCTBBlockPrototype::getDataField(), DCCTBDataParser::getDecString(), mps_fire::i, DCCTBBlockPrototype::increment(), DCCTBDataParser::mapper(), DCCTBBlockPrototype::mapperFields_, DCCTBBlockPrototype::parseData(), DCCTBBlockPrototype::parser_, DCCTBTowerBlock::parseXtalData(), PHYSICTRIGGER, SR_NREAD, srpBlock_, DCCTBDataParser::srpBlockSize(), AlCaHLTBitMon_QueryRunRegistry::string, suppress, DCCTBDataParser::tcc1Id(), DCCTBDataParser::tcc2Id(), DCCTBDataParser::tcc3Id(), DCCTBDataParser::tcc4Id(), tccBlocks_, DCCTBDataParser::tccBlockSize(), ecaldqm::tccId(), towerBlocks_, TOWERHEADER_SIZE, TRAILER_SIZE, ECALTBParserBlockException::what(), and DCCTBBlockPrototype::wordCounter_.

  : 
DCCTBBlockPrototype(parser,"DCCHEADER", buffer, numbBytes,wordsToEnd)
,dccTrailerBlock_(nullptr),srpBlock_(nullptr),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 ( )

override

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_ !=        nullptr ) { delete srpBlock_;       }
    if(dccTrailerBlock_ != nullptr ) { 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, MillePedeFileConverter_cfg::out, 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(), RecoTauValidation_cfi::header, mps_fire::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_, 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_, 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 84 of file DCCEventBlock.h.

References srpBlock_.

Referenced by compare().

{ return srpBlock_;        }

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

inline

Definition at line 83 of file DCCEventBlock.h.

References tccBlocks_.

Referenced by compare().

{ return tccBlocks_;       }

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

inline

Definition at line 82 of file DCCEventBlock.h.

References towerBlocks_.

Referenced by compare().

{ return towerBlocks_;     }

std::vector< DCCTBTowerBlock * > DCCTBEventBlock::towerBlocksById

(

uint32_t

towerId

)

Definition at line 548 of file DCCEventBlock.cc.

References MillePedeFileConverter_cfg::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;
}

DCCTBTrailerBlock * DCCTBEventBlock::trailerBlock ( )

inline

Definition at line 85 of file DCCEventBlock.h.

References dccTrailerBlock_.

Referenced by compare().

{ return dccTrailerBlock_; }

Member Data Documentation

DCCTBTrailerBlock* DCCTBEventBlock::dccTrailerBlock_

protected

Definition at line 75 of file DCCEventBlock.h.

Referenced by DCCTBEventBlock(), displayEvent(), eventErrorString(), eventHasErrors(), trailerBlock(), and ~DCCTBEventBlock().

bool DCCTBEventBlock::emptyEvent

protected

Definition at line 78 of file DCCEventBlock.h.

Referenced by dataCheck(), and DCCTBEventBlock().

DCCTBSRPBlock* DCCTBEventBlock::srpBlock_

protected

Definition at line 76 of file DCCEventBlock.h.

Referenced by compare(), DCCTBEventBlock(), displayEvent(), eventErrorString(), eventHasErrors(), srpBlock(), and ~DCCTBEventBlock().

std::vector< DCCTBTCCBlock * > DCCTBEventBlock::tccBlocks_

protected

Definition at line 74 of file DCCEventBlock.h.

Referenced by compare(), DCCTBEventBlock(), displayEvent(), eventErrorString(), eventHasErrors(), tccBlocks(), and ~DCCTBEventBlock().

std::vector< DCCTBTowerBlock * > DCCTBEventBlock::towerBlocks_

protected

Definition at line 73 of file DCCEventBlock.h.

Referenced by compare(), DCCTBEventBlock(), displayEvent(), eventErrorString(), eventHasErrors(), towerBlocks(), towerBlocksById(), and ~DCCTBEventBlock().

uint32_t DCCTBEventBlock::wordBufferOffset_

protected

Definition at line 77 of file DCCEventBlock.h.

Referenced by displayEvent().