DCCEEEventBlock.cc

Go to the documentation of this file.

#include "EventFilter/EcalRawToDigi/interface/DCCDataUnpacker.h"
#include "EventFilter/EcalRawToDigi/interface/EcalDCCHeaderRuntypeDecoder.h"
#include "EventFilter/EcalRawToDigi/interface/EcalElectronicsMapper.h"
#include "EventFilter/EcalRawToDigi/interface/DCCMemBlock.h"

#include "EventFilter/EcalRawToDigi/interface/DCCEEEventBlock.h"
#include "EventFilter/EcalRawToDigi/interface/DCCFEBlock.h"
#include "EventFilter/EcalRawToDigi/interface/DCCSCBlock.h"
#include "EventFilter/EcalRawToDigi/interface/DCCEETCCBlock.h"
#include "EventFilter/EcalRawToDigi/interface/DCCEESRPBlock.h"
#include <sys/time.h>

#include <iomanip>
#include <sstream>

DCCEEEventBlock::DCCEEEventBlock(DCCDataUnpacker* u,
                                 EcalElectronicsMapper* m,
                                 bool hU,
                                 bool srpU,
                                 bool tccU,
                                 bool feU,
                                 bool memU,
                                 bool forceToKeepFRdata)
    : DCCEventBlock(u, m, hU, srpU, tccU, feU, memU, forceToKeepFRdata) {
  //Builds a tower unpacker block
  towerBlock_ = new DCCSCBlock(u, m, this, feUnpacking_, forceToKeepFRdata_);

  //Builds a srp unpacker block
  srpBlock_ = new DCCEESRPBlock(u, m, this, srpUnpacking_);

  //Builds a tcc unpacker block
  tccBlock_ = new DCCEETCCBlock(u, m, this, tccUnpacking_);
}

void DCCEEEventBlock::unpack(const uint64_t* buffer, size_t numbBytes, unsigned int expFedId) {
  reset();

  eventSize_ = numbBytes;
  data_ = buffer;

  // First Header Word of fed block
  fedId_ = ((*data_) >> H_FEDID_B) & H_FEDID_MASK;
  bx_ = ((*data_) >> H_BX_B) & H_BX_MASK;
  l1_ = ((*data_) >> H_L1_B) & H_L1_MASK;
  triggerType_ = ((*data_) >> H_TTYPE_B) & H_TTYPE_MASK;

  // Check if fed id is the same as expected...
  if (fedId_ != expFedId) {
    if (!DCCDataUnpacker::silentMode_) {
      edm::LogWarning("IncorrectEvent") << "\n For event L1A: " << l1_ << "\n Expected FED id is: " << expFedId
                                        << " while current FED id is: " << fedId_
                                        << "\n => Skipping to next fed block...";
    }

    //TODO : add this to an error event collection

    return;
  }

  // Check if this event is an empty event
  if (eventSize_ == EMPTYEVENTSIZE) {
    if (!DCCDataUnpacker::silentMode_) {
      edm::LogWarning("IncorrectEvent") << "\n Event L1A: " << l1_ << " is empty for fed: " << fedId_
                                        << "\n => Skipping to next fed block...";
    }
    return;

  }

  //Check if event size allows at least building the header
  else if (eventSize_ < HEADERSIZE) {
    if (!DCCDataUnpacker::silentMode_) {
      edm::LogError("IncorrectEvent") << "\n Event L1A: " << l1_ << " in fed: " << fedId_ << "\n Event size is "
                                      << eventSize_ << " bytes while the minimum is " << HEADERSIZE << " bytes"
                                      << "\n => Skipping to next fed block...";
    }

    //TODO : add this to a dcc size error collection

    return;
  }

  //Second Header Word of fed block
  data_++;

  blockLength_ = (*data_) & H_EVLENGTH_MASK;
  dccErrors_ = ((*data_) >> H_ERRORS_B) & H_ERRORS_MASK;
  runNumber_ = ((*data_) >> H_RNUMB_B) & H_RNUMB_MASK;

  if (eventSize_ != blockLength_ * 8) {
    if (!DCCDataUnpacker::silentMode_) {
      edm::LogError("IncorrectEvent") << "\n Event L1A: " << l1_ << " in fed: " << fedId_ << "\n size is " << eventSize_
                                      << " bytes while " << (blockLength_ * 8) << " are set in the event header "
                                      << "\n => Skipping to next fed block...";
      //TODO : add this to a dcc size error collection
    }
    return;
  }

  //Third Header Word  of fed block
  data_++;

  // bits 0.. 31 of the 3rd DCC header word
  runType_ = (*data_) & H_RTYPE_MASK;

  fov_ = ((*data_) >> H_FOV_B) & H_FOV_MASK;

  // bits 32.. 47 of the 3rd DCC header word
  detailedTriggerType_ = ((*data_) >> H_DET_TTYPE_B) & H_DET_TTYPE_MASK;

  //Forth Header Word
  data_++;
  orbitCounter_ = ((*data_) >> H_ORBITCOUNTER_B) & H_ORBITCOUNTER_MASK;
  sr_ = ((*data_) >> H_SR_B) & B_MASK;
  zs_ = ((*data_) >> H_ZS_B) & B_MASK;
  tzs_ = ((*data_) >> H_TZS_B) & B_MASK;

  // MEM (forces readout of MEM channels if enabled)is only used in the EE DCCs and for FOV >1
  mem_ = ((*data_) >> H_MEM_B) & B_MASK;
  if (fov_ < 2) {
    mem_ = 0;
  }

  bool ignoreSR(true);

  srChStatus_ = ((*data_) >> H_SRCHSTATUS_B) & H_CHSTATUS_MASK;

  // getting TCC channel status bits
  tccChStatus_[0] = ((*data_) >> H_TCC1CHSTATUS_B) & H_CHSTATUS_MASK;
  tccChStatus_[1] = ((*data_) >> H_TCC2CHSTATUS_B) & H_CHSTATUS_MASK;
  tccChStatus_[2] = ((*data_) >> H_TCC3CHSTATUS_B) & H_CHSTATUS_MASK;
  tccChStatus_[3] = ((*data_) >> H_TCC4CHSTATUS_B) & H_CHSTATUS_MASK;

  // FE  channel Status data
  int channel(0);
  for (int dw = 0; dw < 5; dw++) {
    data_++;
    for (int i = 0; i < 14; i++, channel++) {
      unsigned int shift = i * 4;  //each channel has 4 bits
      feChStatus_[channel] = ((*data_) >> shift) & H_CHSTATUS_MASK;
    }
  }

  // debugging
  //display(cout);

  // pointer for the
  std::vector<short>::iterator it;

  // Update number of available dwords
  dwToEnd_ = blockLength_ - HEADERLENGTH;

  int STATUS = unpackTCCBlocks();

  if (STATUS != STOP_EVENT_UNPACKING && (feUnpacking_ || srpUnpacking_)) {
    //NMGA note : SR comes before TCC blocks
    // Emmanuelle please change this in the digi to raw

    // Unpack SRP block
    if (srChStatus_ != CH_TIMEOUT && srChStatus_ != CH_DISABLED) {
      STATUS = srpBlock_->unpack(&data_, &dwToEnd_, SRP_NUMBFLAGS);
      if (STATUS == BLOCK_UNPACKED) {
        ignoreSR = false;
      }
    }
  }

  // See number of FE channels that we need according to the trigger type //
  // TODO : WHEN IN LOCAL MODE WE SHOULD CHECK RUN TYPE
  unsigned int numbChannels(0);

  if (triggerType_ == PHYSICTRIGGER) {
    numbChannels = 68;
  } else if (triggerType_ == CALIBRATIONTRIGGER) {
    numbChannels = 70;
  } else {
    if (!DCCDataUnpacker::silentMode_) {
      edm::LogError("IncorrectEvent") << "\n Event L1A: " << l1_ << " in fed: " << fedId_
                                      << "\n Event has an unsupported trigger type " << triggerType_
                                      << "\n => Skipping to next fed block...";
      //TODO : add this to a dcc trigger type error collection
    }
    return;
  }

  // note: there is no a-priori check that number_active_channels_from_header
  //          equals number_channels_found_in_data.
  //          The checks are doing f.e. by f.e. only.

  if (feUnpacking_ || memUnpacking_) {
    it = feChStatus_.begin();

    // fields for tower recovery code
    unsigned int next_tower_id = 1000;
    const uint64_t* next_data = data_;
    unsigned int next_dwToEnd = dwToEnd_;

    // looping over FE channels, i.e. tower blocks
    for (unsigned int chNumber = 1; chNumber <= numbChannels && STATUS != STOP_EVENT_UNPACKING; chNumber++, it++) {
      //for( unsigned int i=1; chNumber<= numbChannels; chNumber++, it++ ){

      const short chStatus(*it);

      // skip unpacking if channel disabled
      if (chStatus == CH_DISABLED) {
        continue;
      }

      // force MEM readout if mem_ is enabled in EEs regardless on ch suppress status flag
      if (chStatus == CH_SUPPRESS && !mem_) {
        continue;
      }

      // issuiung messages for problematic cases, even though handled by the DCC
      // and skip channel
      if (chStatus == CH_TIMEOUT || chStatus == CH_HEADERERR || chStatus == CH_LINKERR || chStatus == CH_LENGTHERR ||
          chStatus == CH_IFIFOFULL || chStatus == CH_L1AIFIFOFULL) {
        if (!DCCDataUnpacker::silentMode_) {
          const int val = unpacker_->getCCUValue(fedId_, chNumber);
          const bool ttProblem = (val == 13) || (val == 14);
          if (!ttProblem) {
            edm::LogWarning("IncorrectBlock")
                << "Bad channel status: " << chStatus << " in the DCC channel: " << chNumber << " (LV1 " << l1_
                << " fed " << fedId_ << ")\n"
                << "  => DCC channel is not being unpacked";
          }
        }
        continue;
      }

      // preserve data pointer
      const uint64_t* const prev_data = data_;
      const unsigned int prev_dwToEnd = dwToEnd_;

      // skip corrupted/problematic data block
      if (chNumber >= next_tower_id) {
        data_ = next_data;
        dwToEnd_ = next_dwToEnd;
        next_tower_id = 1000;
      }

      // Unpack Tower (Xtal Block)
      if (feUnpacking_ && chNumber <= 68) {
        //  in case of SR (data are 0 suppressed)
        if (sr_) {
          const bool applyZS = (fov_ == 0) ||  // backward compatibility with FOV = 0;
                               ignoreSR || (chStatus == CH_FORCEDZS1) ||
                               ((srpBlock_->srFlag(chNumber) & SRP_SRVAL_MASK) != SRP_FULLREADOUT);

          STATUS = towerBlock_->unpack(&data_, &dwToEnd_, applyZS, chNumber);

          // If there is a decision to fully suppress data this is updated in channel status by the dcc
          //if ( ( srpBlock_->srFlag(chNumber) & SRP_SRVAL_MASK) != SRP_NREAD ){
          //    STATUS = towerBlock_->unpack(&data_,&dwToEnd_,applyZS,chNumber);
          //}
        }
        // no SR (possibly 0 suppression flags)
        else {
          // if tzs_ data are not really suppressed, even though zs flags are calculated
          if (tzs_) {
            zs_ = false;
          }
          STATUS = towerBlock_->unpack(&data_, &dwToEnd_, zs_, chNumber);
        }
      }

      // Unpack Mem blocks
      if (memUnpacking_ && chNumber > 68) {
        STATUS = memBlock_->unpack(&data_, &dwToEnd_, chNumber);
      }

      // corruption recovery
      if (STATUS == SKIP_BLOCK_UNPACKING) {
        data_ = prev_data;
        dwToEnd_ = prev_dwToEnd;

        next_tower_id = next_tower_search(chNumber);

        next_data = data_;
        next_dwToEnd = dwToEnd_;

        data_ = prev_data;
        dwToEnd_ = prev_dwToEnd;
      }
    }
    // closing loop over FE/TTblock channels

  }  // check if we need to perform unpacking of FE or mem data

  if (headerUnpacking_)
    addHeaderToCollection();
}

int DCCEEEventBlock::unpackTCCBlocks() {
  int STATUS(BLOCK_UNPACKED);
  std::vector<short>::iterator it;
  unsigned int tccChId(0);
  for (it = tccChStatus_.begin(); it != tccChStatus_.end(); it++, tccChId++) {
    if ((*it) != CH_TIMEOUT && (*it) != CH_DISABLED) {
      STATUS = tccBlock_->unpack(&data_, &dwToEnd_, tccChId);
      if (STATUS == STOP_EVENT_UNPACKING)
        break;
    }
  }
  return STATUS;
}