DCCTBEventBlock Class Reference

#include <DCCEventBlock.h>

Inheritance diagram for DCCTBEventBlock:

Public Member Functions
virtual std::pair< bool, std::string >	compare (DCCTBBlockPrototype *block)
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 16 of file DCCEventBlock.h.

Member Enumeration Documentation

dccFields

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 42 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::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, HLT_2023v12_cff::triggerType, 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::~DCCTBEventBlock ( )

override

Definition at line 191 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

compare() [1/2]

std::pair< bool, std::string > DCCTBBlockPrototype::compare

Definition at line 233 of file DCCBlockPrototype.cc.

                                                                                {
  std::pair<bool, std::string> ret(true, "");

  std::set<DCCTBDataField *, DCCTBDataFieldComparator>::iterator it;
  std::stringstream out;

  out << "\n ======================================================================";
  out << "\n ORIGINAL BLOCK    : ";
  out << "\n Block name : " << name_ << ", size : " << std::dec << blockSize_
      << " bytes, event WOffset : " << wordEventOffset_;
  out << "\n COMPARISION BLOCK : ";
  out << "\n Block name : " << (block->name()) << ", size : " << std::dec << (block->size())
      << " bytes, event WOffset : " << (block->wOffset());
  out << "\n =====================================================================";

  if (block->name() != name_) {
    ret.first = false;
    out << "\n ERROR >> It is not possible to compare blocks with different names ! ";
    ret.second += out.str();
    return ret;
  }

  if (block->size() != blockSize_) {
    ret.first = false;
    out << "\n WARNING >> Blocks have different sizes "
        << "\n WARNING >> Comparision will be carried on untill possible";
  }

  if (block->wOffset() != wordEventOffset_) {
    ret.first = false;
    out << "\n WARNING >> Blocks have different word offset within the event ";
  }

  std::string dataFieldName;

  for (it = mapperFields_->begin(); it != mapperFields_->end(); it++) {
    dataFieldName = (*it)->name();

    uint32_t aValue, bValue;

    //Access original block data fields /////////////////////////////////////////////////////
    try {
      aValue = getDataField(dataFieldName);
    }

    catch (ECALTBParserBlockException &e) {
      ret.first = false;
      out << "\n ERROR ON ORIGINAL BLOCK unable to get data field :" << dataFieldName;
      out << "\n Comparision was stoped ! ";
      ret.second += out.str();
      return ret;
    }

    //Access comparision block data fields ///////////////////////////////////////////////////////
    try {
      bValue = block->getDataField(dataFieldName);
    } catch (ECALTBParserBlockException &e) {
      ret.first = false;
      out << "\n ERROR ON COMPARISION BLOCK unable to get data field :" << dataFieldName
          << "\n Comparision was stoped ! ";
      ret.second += out.str();
      return ret;
    }

    //std::cout<<"\n data Field name "<<dataFieldName<<std::endl;
    //std::cout<<"\n aValue "<<std::dec<<aValue<<std::endl;
    //std::cout<<"\n bValue "<<std::dec<<bValue<<std::endl;

    // Compare values
    if (aValue != bValue) {
      ret.first = false;
      out << "\n Data Field : " << dataFieldName << "\n ORIGINAL BLOCK value : " << std::dec << std::setw(5) << aValue
          << " , COMPARISION BLOCK value : " << std::dec << std::setw(5) << bValue;
      //std::cout<<"\n  debug... "<<out<<std::endl;
    }
  }
  out << "\n ======================================================================\n";
  ret.second = out.str();

  return ret;
}

compare() [2/2]

std::pair< bool, std::string > DCCTBEventBlock::compare

(

DCCTBEventBlock *

block

)

Definition at line 307 of file DCCEventBlock.cc.

References groupFilesInBlocks::block, DCCTBBlockPrototype::compare(), mps_fire::end, MillePedeFileConverter_cfg::out, runTheMatrix::ret, srpBlock_, tccBlocks_, groupFilesInBlocks::temp, 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;
}

dataCheck()

void DCCTBEventBlock::dataCheck

(

)

Definition at line 212 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.empty()) {
    errorString_ += "\n ======================================================================\n";
    errorString_ += std::string(" ") + name_ + std::string(" data fields checks errors : ");
    errorString_ += checkErrors;
    errorString_ += "\n ======================================================================";
    blockError_ = true;
  }
}

displayEvent()

void DCCTBEventBlock::displayEvent

(

std::ostream &

os = std::cout

)

Definition at line 268 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);
  }
}

eventErrorString()

std::string DCCTBEventBlock::eventErrorString

(

)

Definition at line 462 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.empty()) {
        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;
}

eventHasErrors()

bool DCCTBEventBlock::eventHasErrors

(

)

Definition at line 421 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;
}

srpBlock()

DCCTBSRPBlock * DCCTBEventBlock::srpBlock ( )

inline

Definition at line 75 of file DCCEventBlock.h.

References srpBlock_.

{ return srpBlock_; }

tccBlocks()

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

inline

Definition at line 74 of file DCCEventBlock.h.

References tccBlocks_.

{ return tccBlocks_; }

towerBlocks()

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

inline

Definition at line 73 of file DCCEventBlock.h.

References towerBlocks_.

{ return towerBlocks_; }

towerBlocksById()

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

(

uint32_t

towerId

)

Definition at line 521 of file DCCEventBlock.cc.

References MillePedeFileConverter_cfg::e, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, towerBlocks_, and ecaldqm::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;
}

trailerBlock()

DCCTBTrailerBlock * DCCTBEventBlock::trailerBlock ( )

inline

Definition at line 76 of file DCCEventBlock.h.

References dccTrailerBlock_.

Referenced by compare().

{ return dccTrailerBlock_; }

Member Data Documentation

dccTrailerBlock_

DCCTBTrailerBlock* DCCTBEventBlock::dccTrailerBlock_

protected

Definition at line 67 of file DCCEventBlock.h.

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

emptyEvent

bool DCCTBEventBlock::emptyEvent

protected

Definition at line 70 of file DCCEventBlock.h.

Referenced by dataCheck(), and DCCTBEventBlock().

srpBlock_

DCCTBSRPBlock* DCCTBEventBlock::srpBlock_

protected

Definition at line 68 of file DCCEventBlock.h.

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

tccBlocks_

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

protected

Definition at line 66 of file DCCEventBlock.h.

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

towerBlocks_

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

protected

Definition at line 65 of file DCCEventBlock.h.

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

wordBufferOffset_

uint32_t DCCTBEventBlock::wordBufferOffset_

protected

Definition at line 69 of file DCCEventBlock.h.

Referenced by displayEvent().