SVDUnpackerModule.cc

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#include <svd/modules/svdUnpacker/SVDUnpackerModule.h>
 
#include <framework/datastore/DataStore.h>
#include <framework/datastore/StoreObjPtr.h>
#include <framework/logging/Logger.h>
 
#include <boost/crc.hpp>      // for boost::crc_basic, boost::augmented_crc
#define CRC16POLYREV 0x8005   // CRC-16 polynomial, normal representation 
 
#include <arpa/inet.h>
 
#include <sstream>
#include <iomanip>
#include <cstring>
#include <vector>
#include <set>
#include <map>
#include <utility>
#include <algorithm>
 
using namespace std;
using namespace Belle2;
using namespace Belle2::SVD;
 
//-----------------------------------------------------------------
//                 Register the Module
//-----------------------------------------------------------------
REG_MODULE(SVDUnpacker);
 
//-----------------------------------------------------------------
//                 Implementation
//-----------------------------------------------------------------
 
std::string Belle2::SVD::SVDUnpackerModule::m_xmlFileName = std::string("SVDChannelMapping.xml");
 
SVDUnpackerModule::SVDUnpackerModule() : Module(),
  m_mapping(m_xmlFileName),
  m_shutUpFTBError(0),
  m_FADCTriggerNumberOffset(0)
{
  //Set module properties
  setDescription("Produce SVDShaperDigits from RawSVD. NOTE: only zero-suppressed mode is currently supported!");
  setPropertyFlags(c_ParallelProcessingCertified);
 
  addParam("SVDEventInfo", m_svdEventInfoName, "Name of the SVDEventInfo object", string(""));
  addParam("rawSVDListName", m_rawSVDListName, "Name of the raw SVD List", string(""));
  addParam("svdShaperDigitListName", m_svdShaperDigitListName, "Name of the SVDShaperDigits list", string(""));
  addParam("shutUpFTBError", m_shutUpFTBError,
           "if >0 is the number of reported FTB header ERRORs before quiet operations. If <0 full log produced.", -1);
  addParam("FADCTriggerNumberOffset", m_FADCTriggerNumberOffset,
           "number to be added to the FADC trigger number to match the main trigger number", 0);
  addParam("svdDAQDiagnosticsListName", m_svdDAQDiagnosticsListName, "Name of the DAQDiagnostics  list", string(""));
  addParam("softwarePipelineAddressEmulation", m_emulatePipelineAddress, "Estimate emulated pipeline address", bool(true));
  addParam("killDigitsFromUpsetAPVs", m_killUpsetDigits, "Delete digits from upset APVs", bool(false));
  addParam("silentlyAppend", m_silentAppend, "Append digits to a pre-existing non-empty storeArray", bool(false));
  addParam("badMappingFatal", m_badMappingFatal, "Throw B2FATAL if there's a wrong payload in the database", bool(false));
  addParam("UnpackerErrorRate", m_errorRate, "Unpacker will print one error every UnpackerErrorRate", int(1000));
  addParam("PrintRawData", m_printRaw, "Printing Raw data words for debugging", bool(false));
}
 
SVDUnpackerModule::~SVDUnpackerModule()
{
}
 
void SVDUnpackerModule::initialize()
{
  m_eventMetaDataPtr.isRequired();
  // Don't panic if no SVD data.
  m_rawSVD.isOptional(m_rawSVDListName);
 
  // Register default SVDEventInfo for unpacking Raw Data
  m_svdEventInfoPtr.registerInDataStore(m_svdEventInfoName, DataStore::c_ErrorIfAlreadyRegistered);
 
  m_storeDAQDiagnostics.registerInDataStore(m_svdDAQDiagnosticsListName);
  m_svdDAQDiagnosticsListName = m_storeDAQDiagnostics.getName();
 
  m_storeShaperDigits.registerInDataStore(m_svdShaperDigitListName);
  m_svdShaperDigitListName = m_storeShaperDigits.getName();
 
  m_diagnostics.reserve(2048);
  m_digitsWithDiag.reserve(8192);
  m_digitSortKeys.reserve(8192);
  m_apvsByPipeline.reserve(2048);
 
}
 
void SVDUnpackerModule::beginRun()
{
  if (!m_mapping.isValid())
    B2FATAL("no valid SVD Channel Mapping. We stop here.");
 
  m_wrongFTBcrc = 0;
  if (m_mapping.hasChanged()) { m_map = std::make_unique<SVDOnlineToOfflineMap>(m_mapping->getFileName()); }
 
  if (! m_map) { //give up
    B2ERROR("SVD xml map not loaded." << std::endl <<
            "No SVDShaperDigit will be produced for this run!");
    return;
  }
 
  //number of FADC boards
  nFADCboards = m_map->getFADCboardsNumber();
 
  //passing APV<->FADC mapping from SVDOnlineToOfflineMap object
  APVmap = &(m_map->APVforFADCmap);
 
  //setting UnpackerErrorRate factor to use it for BadMapping error suppression
  m_map->setErrorRate(m_errorRate);
 
  nTriggerMatchErrors = -1;
  nEventMatchErrors = -1;
  nUpsetAPVsErrors = -1;
  nSEURecoveryCase = -1;
  nErrorFieldErrors = -1;
  nMissingAPVsErrors = -1;
  nFADCMatchErrors = -1;
  nAPVErrors = -1;
  nFTBFlagsErrors = -1;
  nEventInfoMatchErrors = -1;
 
  seenHeadersAndTrailers = 0;
 
  //get the relative time shift
  if (!m_svdGlobalConfig.isValid())
    B2FATAL("SVDGlobalConfigParameters not valid!!");
 
  m_relativeTimeShift = m_svdGlobalConfig->getRelativeTimeShift();
 
}
 
#ifndef __clang__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstack-usage="
#endif
void SVDUnpackerModule::event()
{
  if (!m_rawSVD || !m_rawSVD.getEntries())
    return;
 
  if (!m_silentAppend && m_storeShaperDigits && m_storeShaperDigits.getEntries())
    B2WARNING("Unpacking SVDShaperDigits to a non-empty pre-existing \n"
              << "StoreArray. This can lead to undesired behaviour. At least\n"
              << "remember to use SVDShaperDigitSorter in your path and \n"
              << "set the silentlyAppend parameter of SVDUnpacker to true.");
 
  // Diagnostics, digits and pipeline addresses are accumulated in event-local
  // buffers and moved to the DataStore only once, at the end of the event.
  m_diagnostics.clear();
  m_digitsWithDiag.clear();
  m_digitSortKeys.clear();
  m_apvsByPipeline.clear();
 
  // index in m_diagnostics of the diagnostic of the current APV
  size_t currentDiagIdx = size_t(-1);
 
  if (!m_eventMetaDataPtr.isValid()) {  // give up...
    B2ERROR("Missing valid EventMetaData." << std::endl << "No SVDShaperDigit produced for this event!");
    return;
  }
 
  bool nAPVmatch = true;
  bool badMapping = false;
  bool badHeader = false;
  bool badTrailer = false;
  bool missedHeader = false;
  bool missedTrailer = false;
 
  // flag to set SVDEventInfo once per event
  bool isSetEventInfo = false;
 
  //flag to set nAPVsamples in SVDEventInfo once per event
  bool isSetNAPVsamples = false;
 
  unsigned short nAPVheaders = 999;
  uint64_t seenAPVHeaders = 0; // bit mask of the (6-bit) APV numbers seen since the last FADC trailer
 
  unsigned short nEntries_rawSVD = m_rawSVD.getEntries();
  auto eventNo = m_eventMetaDataPtr->getEvent();
 
  short fadc = 255, apv = 63;
 
  // cache of the online-to-offline sensor lookup, valid for the current (fadc, apv)
  int cachedChipID = -1;
  SVDOnlineToOfflineMap::SensorInfo cachedSensorInfo{};
 
  // scratch buffers hoisted out of the loops to avoid re-allocations
  std::vector<unsigned short> nWords;
  std::vector<uint32_t*> data32tab; //vector of pointers
  vector<uint32_t> crc16vec; // input words for the CRC16 check, already converted with htonl
 
  unsigned short cntFADCboards = 0;
  for (unsigned int i = 0; i < nEntries_rawSVD; i++) {
 
    RawSVD* rawSVD = m_rawSVD[i];
    unsigned int numEntries_rawSVD = rawSVD->GetNumEntries();
    for (unsigned int j = 0; j < numEntries_rawSVD; j++) {
 
      const unsigned short maxNumOfCh = rawSVD->GetMaxNumOfCh(j);
 
      nWords.resize(maxNumOfCh);
      data32tab.resize(maxNumOfCh);
      for (unsigned int k = 0; k < maxNumOfCh; k++) {
        nWords[k] = rawSVD->GetDetectorNwords(j, k);
        data32tab[k] = (uint32_t*)rawSVD->GetDetectorBuffer(j, k); // points at the beginning of the 1st buffer
      }
 
      unsigned short ftbError = 0;
      unsigned short trgType = 0;
      unsigned short trgNumber = 0;
      unsigned short daqMode = -1;
      unsigned short daqType = 0;
      unsigned short cmc1;
      unsigned short cmc2;
      unsigned short apvErrors;
      unsigned short pipAddr;
      unsigned short ftbFlags = 0;
      unsigned short apvErrorsOR = 0;
 
      bool is3sampleData = false;
      bool is6sampleData = false;
 
      for (unsigned int buf = 0; buf < maxNumOfCh; buf++) { // loop over 4(COPPER) or 48(PCIe40) buffers
 
        if (data32tab[buf] == nullptr || nWords[buf] == 0) {
          if (data32tab[buf] != nullptr || nWords[buf] != 0) {
            B2WARNING("Invalid combination of buffer pointer and nWords:" <<
                      LogVar("COPPER/PCIe40 ID", i) <<
                      LogVar("COPPER/PCIe40 Entry", j) <<
                      LogVar("COPPER/PCIe40 Channel", buf) <<
                      LogVar("data32tab[buf]", data32tab[buf]) <<
                      LogVar("nWords[buf]", nWords[buf]));
          }
          continue;
        }
        if (m_printRaw) printB2Debug(data32tab[buf], data32tab[buf], &data32tab[buf][nWords[buf] - 1], nWords[buf]);
 
        cntFADCboards++;
 
        missedHeader = false;
        missedTrailer = false;
 
        // diagnostics created for this buffer: [bufDiagStart, m_diagnostics.size())
        const size_t bufDiagStart = m_diagnostics.size();
 
        uint32_t* data32_it = data32tab[buf];
        short strip, sample[6];
        crc16vec.clear();
 
        //reset value for headers and trailers check
        seenHeadersAndTrailers = 0;
 
        for (; data32_it != &data32tab[buf][nWords[buf]]; data32_it++) {
          m_data32 = *data32_it; //put current 32-bit frame to union
 
          if (m_data32 == 0xffaa0000) {   // first part of FTB header
            crc16vec.clear(); // clear the input container for crc16 calculation
            crc16vec.push_back(htonl(m_data32));
 
            seenHeadersAndTrailers |= 0x1; // we found FTB header
 
            data32_it++; // go to 2nd part of FTB header
            crc16vec.push_back(htonl(*data32_it));
 
            m_data32 = *data32_it; //put the second 32-bit frame to union
 
            ftbError = m_FTBHeader.errorsField;
 
            if (ftbError != 240) {
              nErrorFieldErrors++;
 
              if (!(nErrorFieldErrors % m_errorRate) or nErrorFieldErrors < 100) {
                switch (ftbError - 240) {
                  case 3:
                    B2ERROR("FADC Event Number is different from (FTB & TTD) Event Numbers");
                    break;
                  case 5:
                    B2ERROR("TTD Event Number is different from (FTB & FADC) Event Numbers");
                    break;
                  case 6:
                    B2ERROR("FTB Event Number is different from (TTD & FADC) Event Numbers");
                    break;
                  case 7:
                    B2ERROR("(FTB, TTD & FADC) Event Numbers are different from each other");
                    break;
                  default:
                    B2ERROR("Problem with errorsField variable in FTB Header" << LogVar("abnormal value", ftbError));
                }
              }
            }
 
            if (m_FTBHeader.eventNumber !=
                (eventNo & 0xFFFFFF)) {
              nEventMatchErrors++;
              if (m_shutUpFTBError && !(nEventMatchErrors % m_errorRate)) { //
                m_shutUpFTBError -= 1;
                B2ERROR("Event number mismatch detected! The event number given by EventMetaData object is different from the one in the FTB Header."
                        << LogVar("Expected event number & 0xFFFFFF",
                                  (eventNo & 0xFFFFFF)) << LogVar("Event number in the FTB", m_FTBHeader.eventNumber));
              }
            }
 
            continue;
          } // is FTB Header
 
          crc16vec.push_back(htonl(m_data32));
 
          if (m_MainHeader.check == 6) { // FADC header
 
            seenHeadersAndTrailers |= 0x2; //we found FADC Header
 
            fadc = m_MainHeader.FADCnum;
            trgType = m_MainHeader.trgType;
            trgNumber = m_MainHeader.trgNumber;
            daqMode = m_MainHeader.DAQMode;
            daqType = m_MainHeader.DAQType;
 
            //Let's add run-dependent info: daqMode="11" in case of 3-mixed-6 sample acquisition mode.
            if (daqType) daqMode = 3;
 
            nAPVheaders = 0; // start counting APV headers for this FADC
            nAPVmatch = true; //assume correct # of APV headers
            badMapping = false; //assume correct mapping
            badHeader = false;
            badTrailer = false;
 
            is3sampleData = false;
            is6sampleData = false;
 
            if (daqMode == 0) B2ERROR("SVDDataFormatCheck: the event " << eventNo <<
                                        " is apparently taken with 1-sample mode, this is not expected.");
            if (daqMode == 1) is3sampleData = true;
            if (daqMode == 2) is6sampleData = true;
 
            if (
              m_MainHeader.trgNumber !=
              ((eventNo - m_FADCTriggerNumberOffset) & 0xFF)) {
 
              nTriggerMatchErrors++;
              if (!(nTriggerMatchErrors % m_errorRate))
                B2ERROR("Event number mismatch detected! The event number given by EventMetaData object is different from the one in the FADC Header. "
                        << LogVar("Event number", eventNo) << LogVar("FADC", fadc) << LogVar("Trigger number LSByte reported by the FADC",
                            m_MainHeader.trgNumber) << LogVar("+ offset", m_FADCTriggerNumberOffset) << LogVar("expected", (eventNo & 0xFF)));
              badHeader = true;
            }
 
            // create SVDModeByte object from MainHeader vars
            m_SVDModeByte = SVDModeByte(m_MainHeader.runType, 0, daqMode, m_MainHeader.trgTiming);
 
            // create SVDEventInfo and fill it with SVDModeByte & SVDTriggerType objects
            if (!isSetEventInfo) {
              m_SVDTriggerType = SVDTriggerType(trgType);
              m_svdEventInfoPtr.create();
              m_svdEventInfoPtr->setModeByte(m_SVDModeByte);
              m_svdEventInfoPtr->setTriggerType(m_SVDTriggerType);
              m_svdEventInfoPtr->setAPVClock(m_hwClock);
 
              //set relative time shift
              m_svdEventInfoPtr->setRelativeShift(m_relativeTimeShift);
              // set X-talk info online from Raw Data
              m_svdEventInfoPtr->setCrossTalk(m_MainHeader.xTalk);
 
              isSetEventInfo = true;
            } else {  // let's check if the current SVDModeByte and SVDTriggerType are consistent with the one stored in SVDEventInfo
              if (m_SVDModeByte !=  m_svdEventInfoPtr->getModeByte())  {m_svdEventInfoPtr->setMatchModeByte(false); badHeader = true; nEventInfoMatchErrors++;}
              if (trgType != (m_svdEventInfoPtr->getTriggerType()).getType()) { m_svdEventInfoPtr->setMatchTriggerType(false);  badHeader = true; nEventInfoMatchErrors++;}
            }
          } // is FADC header
 
          if (m_APVHeader.check == 2) { // APV header
 
            nAPVheaders++;
            apv = m_APVHeader.APVnum;
            seenAPVHeaders |= (uint64_t(1) << apv);
 
            cmc1 = m_APVHeader.CMC1;
            cmc2 = m_APVHeader.CMC2;
            apvErrors = m_APVHeader.apvErr;
            pipAddr = m_APVHeader.pipelineAddr;
 
            if (apvErrors != 0) {
              nAPVErrors++;
              if (!(nAPVErrors % m_errorRate)
                  or nAPVErrors < 100) B2ERROR("APV error has been detected." << LogVar("FADC", fadc) << LogVar("APV", apv) << LogVar("Error value",
                                                 apvErrors));
            }
            // temporary SVDDAQDiagnostic object (no info from trailers and APVmatch code)
            m_diagnostics.emplace_back(trgNumber, trgType, pipAddr, cmc1, cmc2, apvErrors, ftbError, true,
                                       nAPVmatch,
                                       badHeader, missedHeader, missedTrailer,
                                       fadc, apv);
            currentDiagIdx = m_diagnostics.size() - 1;
 
            m_apvsByPipeline.push_back((uint32_t(pipAddr) << 16) | (uint32_t(fadc) << 8) | uint32_t(apv));
 
            // Let's check if the data frame does not come after APV header with piplAddr = 255 (special SEU recovery pseudo-data)
            if (pipAddr == 255) {
              data32_it++;
              m_data32 = *data32_it;
              if (m_data_A.check == 0) B2ERROR("The strip data frame is detected for the special SEU recovery mode. " << LogVar("pipline address",
                                                 pipAddr) << "This is unexpected!");
              data32_it--;
              m_data32 = *data32_it;
            }
 
          } //is APV Header
 
          if (m_data_A.check == 0) { // data
            strip = m_data_A.stripNum;
 
            sample[0] = m_data_A.sample1;
            sample[1] = m_data_A.sample2;
            sample[2] = m_data_A.sample3;
 
            sample[3] = 0;
            sample[4] = 0;
            sample[5] = 0;
 
            // Let's check the next rawdata word to determine if we acquired 3 or 6 sample
            data32_it++;
            m_data32 = *data32_it;
 
            if (m_data_B.check == 0 && strip == m_data_B.stripNum) { // 2nd data frame with the same strip number -> six samples
 
              if (!isSetNAPVsamples) {
                m_svdEventInfoPtr->setNSamples(6);
                isSetNAPVsamples = true;
              } else {
                if (is3sampleData)
                  B2ERROR("DAQMode value (indicating 3-sample acquisition mode) doesn't correspond to the actual number of samples (6) in the data! The data might be corrupted!");
              }
 
              crc16vec.push_back(htonl(m_data32));
 
              sample[3] = m_data_B.sample4;
              sample[4] = m_data_B.sample5;
              sample[5] = m_data_B.sample6;
            }
 
            else { // three samples
              data32_it--;
              m_data32 = *data32_it;
 
              if (!isSetNAPVsamples) {
                m_svdEventInfoPtr->setNSamples(3);
                isSetNAPVsamples = true;
              } else {
                if (is6sampleData)
                  B2ERROR("DAQMode value (indicating 6-sample acquisition mode) doesn't correspond to the actual number of samples (3) in the data! The data might be corrupted!");
              }
            }
 
            // Generating SVDShaperDigit object; the sensor lookup is cached
            // and refreshed only when the (fadc, apv) combination changes
            const int chipID = (int(fadc) << 8) | int(apv);
            if (chipID != cachedChipID) {
              cachedSensorInfo = m_map->getSensorInfo(fadc, apv);
              cachedChipID = chipID;
            }
            if (cachedSensorInfo.m_sensorID) {
              const short cellID = m_map->getStripNumber(strip, cachedSensorInfo);
              // key packing (sensorID, side with U first, strip, insertion index):
              // sorting the keys reproduces the SVDShaperDigit::operator< ordering,
              // with ties resolved in favour of the first inserted digit
              m_digitSortKeys.push_back((uint64_t(VxdID::baseType(cachedSensorInfo.m_sensorID)) << 48)
                                        | (uint64_t(cachedSensorInfo.m_uSide ? 0 : 1) << 47)
                                        | (uint64_t(uint16_t(cellID) ^ 0x8000) << 31)
                                        | uint64_t(m_digitsWithDiag.size()));
              m_digitsWithDiag.emplace_back(SVDShaperDigit(cachedSensorInfo.m_sensorID, cachedSensorInfo.m_uSide, cellID, sample, 0),
                                            currentDiagIdx);
            } else if (m_badMappingFatal) {
              B2FATAL("Respective FADC/APV combination not found -->> incorrect payload in the database! ");
            } else {
              badMapping = true;
            }
 
          }  //is data frame
 
 
          if (m_FADCTrailer.check == 14)  { // FADC trailer
 
            seenHeadersAndTrailers |= 0x4; // we found FADC trailer
 
            //additional check if we have a faulty/fake FADC that is not in the map
            if (APVmap->find(fadc) == APVmap->end()) badMapping = true;
 
            //comparing number of APV chips and the number of APV headers, for the current FADC
            unsigned short nAPVs = APVmap->count(fadc);
 
            if (nAPVheaders == 0) {
              m_diagnostics.emplace_back(0, 0, 0, 0, 0, 0, ftbError, true, nAPVmatch, badHeader, 0, 0, fadc, 0);
              currentDiagIdx = m_diagnostics.size() - 1;
            }
 
            if (nAPVs != nAPVheaders) {
              // There is an APV missing, detect which it is.
              for (const auto& fadcApv : *APVmap) {
                if (fadcApv.first != fadc) continue;
                if (!((seenAPVHeaders >> fadcApv.second) & 1)) {
                  // We have a missing APV. Look if it is a known one.
                  auto missingRec = m_missingAPVs.find(make_pair(fadcApv.first, fadcApv.second));
                  if (missingRec != m_missingAPVs.end()) {
                    // This is known to be missing, so keep quiet and just update event counters
                    if (missingRec->second.first > eventNo)
                      missingRec->second.first = eventNo;
                    if (missingRec->second.second < eventNo)
                      missingRec->second.second = eventNo;
                  } else {
                    // We haven't seen this previously.
                    nMissingAPVsErrors++;
                    m_missingAPVs.insert(make_pair(
                                           make_pair(fadcApv.first, fadcApv.second),
                                           make_pair(eventNo, eventNo)
                                         ));
                    if (!(nMissingAPVsErrors % m_errorRate)) B2ERROR("missing APV header! " << LogVar("Event number", eventNo) << LogVar("APV",
                                                                       int(fadcApv.second)) << LogVar("FADC",
                                                                           int(fadcApv.first)));
                  }
                }
              }
              nAPVmatch = false;
            } // is nAPVs != nAPVheaders
 
            seenAPVHeaders = 0;
 
            ftbFlags = m_FADCTrailer.FTBFlags;
            if ((ftbFlags >> 5) != 0) badTrailer = true;
            if (ftbFlags != 0) {
              nFTBFlagsErrors++;
              if (!(nFTBFlagsErrors % m_errorRate) or nFTBFlagsErrors < 100) {
                B2ERROR(" FTB Flags variable has an active error bit(s)" << LogVar("on FADC number", fadc));
 
                if (ftbFlags & 16) B2ERROR("----> CRC error has been detected. Data might be corrupted!");
                if (ftbFlags & 8) B2ERROR("----> Bad Event indication has been detected. Data might be corrupted!");
                if (ftbFlags & 4) B2ERROR("----> Double Header has been detected. Data might be corrupted!");
                if (ftbFlags & 2) B2ERROR("----> Time Out has been detected. Data might be corrupted!");
                if (ftbFlags & 1) B2ERROR("----> Event Too Long! Data might be corrupted!");
              }
            }
 
            apvErrorsOR = m_FADCTrailer.apvErrOR;
 
 
          }// is FADC trailer
 
          if (m_FTBTrailer.controlWord == 0xff55)  {// FTB trailer
 
            seenHeadersAndTrailers |= 0x8; // we found FTB trailer
 
            //check CRC16: the trailer word itself is not part of the checksum,
            //the words were already converted with htonl when collected
            crc16vec.pop_back();
 
            //verify CRC16 (table-driven, same parameters and result as
            //boost::crc_basic<16>(0x8005, 0xffff, 0, false, false))
            boost::crc_optimal<16, 0x8005, 0xFFFF, 0, false, false> bcrc;
            bcrc.process_bytes(crc16vec.data(), crc16vec.size() * sizeof(uint32_t));
            unsigned int checkCRC = bcrc.checksum();
 
            if (checkCRC != m_FTBTrailer.crc16) {
              B2WARNING("FTB CRC16 checksum DOES NOT MATCH" << LogVar("for FADC no.", fadc));
              m_wrongFTBcrc++;
            }
 
          } // is FTB trailer
 
        } // end loop over 32-bit frames in each buffer
 
        //Let's check if all the headers and trailers were in place in the last frame
        if (seenHeadersAndTrailers != 0xf) {
          if (!(seenHeadersAndTrailers & 1)) {B2ERROR("Missing FTB Header is detected. SVD data might be corrupted!" << LogVar("Event number", eventNo) << LogVar("FADC", fadc)); missedHeader = true;}
          if (!(seenHeadersAndTrailers & 2)) {B2ERROR("Missing FADC Header is detected -> related FADC number couldn't be retrieved. SVD data might be corrupted! " << LogVar("Event number", eventNo) << LogVar("previous FADC", fadc)); missedHeader = true;}
          if (!(seenHeadersAndTrailers & 4)) {B2ERROR("Missing FADC Trailer is detected. SVD data might be corrupted!" << LogVar("Event number", eventNo) << LogVar("FADC", fadc)); missedTrailer = true;}
          if (!(seenHeadersAndTrailers & 8)) {B2ERROR("Missing FTB Trailer is detected. SVD data might be corrupted!" << LogVar("Event number", eventNo) << LogVar("FADC", fadc)); missedTrailer = true;}
        }
 
        for (size_t d = bufDiagStart; d < m_diagnostics.size(); d++) {
          // adding remaining info to Diagnostic object
          SVDDAQDiagnostic& p = m_diagnostics[d];
          p.setFTBFlags(ftbFlags);
          p.setApvErrorOR(apvErrorsOR);
          p.setAPVMatch(nAPVmatch);
          p.setBadMapping(badMapping);
          p.setBadTrailer(badTrailer);
          p.setMissedHeader(missedHeader);
          p.setMissedTrailer(missedTrailer);
        }
 
      } // end iteration on 4(COPPER)/48(PCIe40) data buffers
 
    } // end event loop
 
  }// end loop over RawSVD objects
 
  // Check the number of FADC boards
  if (cntFADCboards != nFADCboards) { // nFADCboards=52
    nFADCMatchErrors++;
    if (!(nFADCMatchErrors % m_errorRate))  B2ERROR("Number of data objects in rawSVD do not match the number of FADC boards" <<
                                                      LogVar("# of data objects in rawSVD",
                                                             cntFADCboards)  << LogVar("# of FADCs", nFADCboards) << LogVar("Event number", eventNo));
 
    // We override all FADCMatch fields in diagnostics and set it to false.
    for (auto& p : m_diagnostics) {
      p.setFADCMatch(false);
    }
  }
 
  // Sort the (pipeline address, FADC, APV) words and drop duplicates: groups of
  // entries sharing the pipeline address then appear in the same order as in
  // the former map<pipeline, set<pair<fadc, apv>>>
  std::sort(m_apvsByPipeline.begin(), m_apvsByPipeline.end());
  m_apvsByPipeline.erase(std::unique(m_apvsByPipeline.begin(), m_apvsByPipeline.end()), m_apvsByPipeline.end());
 
  // Check if we have special data for SEU recovery mode (pipAddr = 0xFF)
  // If so, let's monitor affected FADC/APV's and the event range with seuRecMap
  // (the entries with pipAddr = 255 are the tail of the sorted list)
  auto seuBegin = std::lower_bound(m_apvsByPipeline.begin(), m_apvsByPipeline.end(), uint32_t(255) << 16);
  for (auto it = seuBegin; it != m_apvsByPipeline.end(); ++it) {
    const unsigned short fadcNo = (*it >> 8) & 0xff;
    const unsigned short apvNo = *it & 0xff;
 
    auto seuRec = m_seuRecMap.find(make_pair(fadcNo, apvNo));
    if (seuRec != m_seuRecMap.end()) {
      if (seuRec->second.first > eventNo)
        seuRec->second.first = eventNo;
      if (seuRec->second.second < eventNo)
        seuRec->second.second = eventNo;
    } else {
      nSEURecoveryCase++;
      m_seuRecMap.insert(make_pair(
                           make_pair(fadcNo, apvNo),
                           make_pair(eventNo, eventNo)
                         ));
      if (!(nSEURecoveryCase % m_errorRate))
        B2ERROR("Special Recovery Data (Dummy APV Header) found due to the detection of Single Event Upset (SEU)!!!" << LogVar("APV",
                int(apvNo)) << LogVar("FADC", int(fadcNo)) << LogVar("Event number", eventNo));
 
    }
    for (auto& pp : m_diagnostics) {
      if (pp.getFADCNumber() == fadcNo and pp.getAPVNumber() == apvNo)
        pp.setSEURecoData(true);
    }
  }
 
  // Detect upset APVs and report/treat.
  // Find the pipeline address seen by most APVs; ties are resolved in favour
  // of the lowest address, as max_element did on the former map.
  unsigned short majorPipeline = 0;
  size_t majorCount = 0;
  unsigned short nPipelines = 0;
  for (size_t b = 0; b < m_apvsByPipeline.size();) {
    const unsigned short pip = m_apvsByPipeline[b] >> 16;
    size_t e = b;
    while (e < m_apvsByPipeline.size() && (m_apvsByPipeline[e] >> 16) == pip) e++;
    nPipelines++;
    if (e - b > majorCount) { majorCount = e - b; majorPipeline = pip; }
    b = e;
  }
 
  // We set emuPipelineAddress fields in diagnostics to this.
  if (m_emulatePipelineAddress && majorCount > 0)
    for (auto& p : m_diagnostics)
      p.setEmuPipelineAddress(majorPipeline);
 
  unsigned short apvsByPipelineSize = nPipelines;
  if (majorCount > 0 && majorPipeline == 255) apvsByPipelineSize = 1;
 
  // And report any upset apvs or update records
  if (apvsByPipelineSize > 1)
    for (size_t b = 0; b < m_apvsByPipeline.size();) {
      const unsigned short pip = m_apvsByPipeline[b] >> 16;
      size_t e = b;
      while (e < m_apvsByPipeline.size() && (m_apvsByPipeline[e] >> 16) == pip) e++;
      if (pip == majorPipeline or pip == 255) { b = e; continue; }
      for (size_t k = b; k < e; k++) {
        const unsigned short fadcNo = (m_apvsByPipeline[k] >> 8) & 0xff;
        const unsigned short apvNo = m_apvsByPipeline[k] & 0xff;
        // We have an upset APV. Look if it is a known one.
        auto upsetRec = m_upsetAPVs.find(make_pair(fadcNo, apvNo));
        if (upsetRec != m_upsetAPVs.end()) {
          // This is known to be upset, so keep quiet and update event counters
          if (upsetRec->second.first > eventNo)
            upsetRec->second.first = eventNo;
          if (upsetRec->second.second < eventNo)
            upsetRec->second.second = eventNo;
        } else {
          // We haven't seen this one previously.
          nUpsetAPVsErrors++;
          m_upsetAPVs.insert(make_pair(
                               make_pair(fadcNo, apvNo),
                               make_pair(eventNo, eventNo)
                             ));
 
          if (!(nUpsetAPVsErrors % m_errorRate)) B2ERROR("Upset APV detected!!!" << LogVar("APV", int(apvNo)) << LogVar("FADC",
                                                           int(fadcNo)) << LogVar("Event number", eventNo));
        }
 
        for (auto& pp : m_diagnostics) {
 
          if (pp.getFADCNumber() == fadcNo and pp.getAPVNumber() == apvNo)
            pp.setUpsetAPV(true);
        }
 
      }
      b = e;
    }
 
  // Sort the digit keys and drop duplicated strips keeping the first occurrence:
  // same ordering and deduplication as the former map<SVDShaperDigit, ...>
  std::sort(m_digitSortKeys.begin(), m_digitSortKeys.end());
 
  // Here we can delete digits coming from upset APVs. We detect them by comparing
  // actual and emulated pipeline address fields in DAQDiagnostics.
  uint64_t lastKeptStrip = ~uint64_t(0); // sentinel that cannot match any key
  for (const uint64_t key : m_digitSortKeys) {
 
    if ((key >> 31) == lastKeptStrip) continue; // duplicated strip
    lastKeptStrip = key >> 31;
 
    const auto& p = m_digitsWithDiag[key & 0x7fffffff];
    if (p.second >= m_diagnostics.size()) continue; // data frame without APV header
    const SVDDAQDiagnostic& d = m_diagnostics[p.second];
    if ((m_killUpsetDigits && d.getPipelineAddress() != d.getEmuPipelineAddress()) || d.getFTBError() != 240
        || d.getFTBFlags()     || d.getAPVError() || !(d.getAPVMatch()) || !(d.getFADCMatch())
        || d.getBadHeader()
        ||  d.getBadMapping() || d.getUpsetAPV() || d.getMissedHeader() || d.getMissedTrailer()) continue;
    m_storeShaperDigits.appendNew(p.first);
  }
 
  // Finally move the diagnostics to the DataStore, in one go.
  for (const auto& d : m_diagnostics)
    m_storeDAQDiagnostics.appendNew(d);
 
  if (!m_svdEventInfoPtr->getMatchTriggerType()) {if (!(nEventInfoMatchErrors % m_errorRate) or nEventInfoMatchErrors < 200) B2WARNING("Inconsistent SVD Trigger Type value for: " << LogVar("Event number", eventNo));}
  if (!m_svdEventInfoPtr->getMatchModeByte())  {if (!(nEventInfoMatchErrors % m_errorRate) or nEventInfoMatchErrors < 200) B2WARNING("Inconsistent SVD ModeByte object for: " << LogVar("Event number", eventNo));}
 
 
} //end event function
#ifndef __clang__
#pragma GCC diagnostic pop
#endif
 
void SVDUnpackerModule::endRun()
{
 
  // Summary report on missing APVs
  if (m_missingAPVs.size() > 0) {
    B2WARNING("SVDUnpacker summary 1: Missing APVs");
    for (const auto& miss : m_missingAPVs)
      B2WARNING(LogVar("Missing APV", miss.first.second) << LogVar("FADC", miss.first.first) << LogVar("since event",
                miss.second.first) << LogVar("to event", miss.second.second));
  }
  if (m_upsetAPVs.size() > 0) {
    B2WARNING("SVDUnpacker summary 2: Upset APVs");
    for (const auto& upst : m_upsetAPVs)
      B2WARNING(LogVar("Upset APV", upst.first.second) << LogVar("FADC", upst.first.first) <<
                LogVar("since event", upst.second.first) << LogVar("to event", upst.second.second));
  }
 
  if (m_seuRecMap.size() > 0) {
    B2WARNING("SVDUnpacker summary 2: Special SEU Recovery Data");
    for (const auto& seu : m_seuRecMap)
      B2WARNING(LogVar("SEU recovery data: APV", seu.first.second) << LogVar("FADC", seu.first.first) <<
                LogVar("since event", seu.second.first) << LogVar("to event", seu.second.second));
  }
 
}
 
 
// additional printing function
void SVDUnpackerModule::printB2Debug(uint32_t* data32, uint32_t* data32_min, uint32_t* data32_max, int nWords)
{
 
  uint32_t* min = std::max((data32 - nWords), data32_min);
  uint32_t* max = std::min((data32 + nWords), data32_max);
 
  size_t counter{0};
  std::stringstream os;
  os << std::hex << std::setfill('0');
  for (uint32_t* ptr = min; ptr <= max; ++ptr) {
    os << std::setw(8) << *ptr;
    if (++counter % 10 == 0) os << std::endl;
    else os << " ";
  }
 
  os << std::endl;
  B2INFO(os.str());
  return;
 
}