/data/refman/pasoursint/CMSSW_6_1_1/src/EventFilter/EcalTBRawToDigi/src/DCCEventBlock.cc

Go to the documentation of this file.

#include "DCCEventBlock.h"
#include "DCCDataParser.h"
#include "DCCDataMapper.h"
#include "DCCTowerBlock.h"
#include "ECALParserException.h"
#include "ECALParserBlockException.h"
#include "DCCSRPBlock.h"
#include "DCCTCCBlock.h"
#include "DCCXtalBlock.h"
#include "DCCTrailerBlock.h"

#include <iomanip>
#include <sstream>

DCCTBEventBlock::DCCTBEventBlock(
        DCCTBDataParser * parser, 
        uint32_t * buffer, 
        uint32_t numbBytes, 
        uint32_t wordsToEnd, 
        uint32_t wordBufferOffset , 
        uint32_t wordEventOffset 
) : 
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(){
        
        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_;}
        
}



void DCCTBEventBlock::dataCheck(){
        
        
        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){

  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::pair<bool,std::string> DCCTBEventBlock::compare(DCCTBEventBlock * block){
        
        // 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;
}
                        
                
                
                
                
                
                
                

bool DCCTBEventBlock::eventHasErrors(){
        
        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;
        
}


std::string DCCTBEventBlock::eventErrorString(){
        
        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;
        
}




std::vector< DCCTBTowerBlock * > DCCTBEventBlock::towerBlocksById(uint32_t towerId){
        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;
}