HcalUnpacker Class Reference

#include <HcalUnpacker.h>

Classes
struct	Collections

Public Member Functions
	HcalUnpacker (int sourceIdOffset, int beg, int end)
	for normal data More...
	HcalUnpacker (int sourceIdOffset)
	For histograms, no begin and end. More...
void	setExpectedOrbitMessageTime (int time)
void	setMode (int mode)
void	unpack (const FEDRawData &raw, const HcalElectronicsMap &emap, std::vector< HcalHistogramDigi > &histoDigis)
void	unpack (const FEDRawData &raw, const HcalElectronicsMap &emap, Collections &conts, HcalUnpackerReport &report, bool silent=false)

Private Member Functions
void	printInvalidDataMessage (const std::string &coll_type, int default_ns, int conflict_ns, bool extended=false)
void	unpackUMNio (const FEDRawData &raw, int slot, Collections &colls)
void	unpackUTCA (const FEDRawData &raw, const HcalElectronicsMap &emap, Collections &conts, HcalUnpackerReport &report, bool silent=false)
void	unpackVME (const FEDRawData &raw, const HcalElectronicsMap &emap, Collections &conts, HcalUnpackerReport &report, bool silent=false)

Private Attributes
int	endSample_
	last sample from fed raw data to copy (if present) More...
int	expectedOrbitMessageTime_
	Expected orbit bunch time (needed to evaluate time differences) More...
int	mode_
int	nPrinted_
int	sourceIdOffset_
	number to subtract from the source id to get the dcc id More...
int	startSample_
	first sample from fed raw data to copy More...
std::set< HcalElectronicsId >	unknownIds_
std::set< HcalElectronicsId >	unknownIdsTrig_
	Recorded to limit number of times a log message is generated. More...

Detailed Description

Definition at line 21 of file HcalUnpacker.h.

Constructor & Destructor Documentation

HcalUnpacker::HcalUnpacker ( int  sourceIdOffset, int  beg, int  end  )

inline

for normal data

Definition at line 44 of file HcalUnpacker.h.

      : sourceIdOffset_(sourceIdOffset),
        startSample_(beg),
        endSample_(end),
        expectedOrbitMessageTime_(-1),
        mode_(0),
        nPrinted_(0) {}

HcalUnpacker::HcalUnpacker ( int  sourceIdOffset )

inline

For histograms, no begin and end.

Definition at line 52 of file HcalUnpacker.h.

      : sourceIdOffset_(sourceIdOffset),
        startSample_(-1),
        endSample_(-1),
        expectedOrbitMessageTime_(-1),
        mode_(0),
        nPrinted_(0) {}

Member Function Documentation

void HcalUnpacker::printInvalidDataMessage ( const std::string &  coll_type, int  default_ns, int  conflict_ns, bool  extended = false  )

private

Definition at line 1070 of file HcalUnpacker.cc.

References constexpr, and MessageLogger_cff::limit.

Referenced by setMode().

                                                          {
  nPrinted_++;

  constexpr int limit = 2;  //print up to limit-1 messages
  if (nPrinted_ >= limit) {
    if (nPrinted_ == limit)
      edm::LogInfo("Invalid Data") << "Suppressing further error messages";

    return;
  }

  std::stringstream message;

  message << "The default " << coll_type << " Collection has " << default_ns
          << " samples per digi, while the current data has " << conflict_ns
          << "!  This data cannot be included with the default collection.";

  if (extended) {
    message << "\nIn order to store this data in the event, it must have a unique tag.  "
            << "To accomplish this, provide two lists to HcalRawToDigi \n"
            << "1) that specifies the number of samples and "
            << "2) that gives tags with which these data are saved.\n"
            << "For example in this case you might add \n"
            << "process.hcalDigis.save" << coll_type << "DataNSamples = cms.untracked.vint32( " << conflict_ns
            << ") \nprocess.hcalDigis.save" << coll_type << "DataTags = cms.untracked.vstring( \"MYDATA\" )";
  }

  edm::LogWarning("Invalid Data") << message.str();
}

void HcalUnpacker::setExpectedOrbitMessageTime ( int  time )

inline

Definition at line 59 of file HcalUnpacker.h.

References expectedOrbitMessageTime_, edmIntegrityCheck::report, CastorRawToDigi_cfi::silent, ntuplemaker::time, and unpack().

Referenced by HcalRawToDigi::HcalRawToDigi().

{ expectedOrbitMessageTime_ = time; }

void HcalUnpacker::setMode ( int  mode )

inline

Definition at line 66 of file HcalUnpacker.h.

References ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, mode_, printInvalidDataMessage(), CastorRawToDigi_cfi::silent, AlCaHLTBitMon_QueryRunRegistry::string, unpackUMNio(), unpackUTCA(), and unpackVME().

Referenced by HcalRawToDigi::HcalRawToDigi().

{ mode_ = mode; }

void HcalUnpacker::unpack	(	const FEDRawData &	raw,
		const HcalElectronicsMap &	emap,
		std::vector< HcalHistogramDigi > &	histoDigis
	)

Definition at line 991 of file HcalUnpacker.cc.

References HcalHTRData::check(), FEDRawData::data(), DetId::det(), runTauDisplay::eid, f, benchmark_cfg::fc, HcalHistogramDigi::getArray(), HcalHTRData::getHistogramFibers(), HcalDCCHeader::getSourceId(), HcalDCCHeader::getSpigotData(), HcalDCCHeader::getSpigotPresent(), HcalHTRData::getSubmodule(), DetId::Hcal, HcalHTRData::isHistogramEvent(), HcalElectronicsMap::lookup(), DetId::null(), HcalElectronicsId::setHTR(), FEDRawData::size(), HcalDCCHeader::SPIGOT_COUNT, DetId::subdetId(), and HcalHTRData::unpackHistogram().

Referenced by HcalHistogramRawToDigi::produce(), HcalRawToDigi::produce(), and setExpectedOrbitMessageTime().

                                                                    {
  // get the DCC header
  const HcalDCCHeader* dccHeader = (const HcalDCCHeader*)(raw.data());
  int dccid = dccHeader->getSourceId() - sourceIdOffset_;

  // check the summary status

  // walk through the HTR data...
  HcalHTRData htr;
  for (int spigot = 0; spigot < HcalDCCHeader::SPIGOT_COUNT; spigot++) {
    if (!dccHeader->getSpigotPresent(spigot))
      continue;

    int retval = dccHeader->getSpigotData(spigot, htr, raw.size());
    // check
    if (retval || !htr.check()) {
      edm::LogWarning("Invalid Data") << "Invalid HTR data observed on spigot " << spigot << " of DCC with source id "
                                      << dccHeader->getSourceId();
      continue;
    }
    if (!htr.isHistogramEvent()) {
      edm::LogWarning("Invalid Data") << "Non-histogram data passed to histogram unpacker on spigot " << spigot
                                      << " of DCC with source id " << dccHeader->getSourceId();
      continue;
    }

    unsigned int smid = htr.getSubmodule();
    int htr_tb = smid & 0x1;
    int htr_slot = (smid >> 1) & 0x1F;
    int htr_cr = (smid >> 6) & 0x1F;

    // find out the fibers
    int f[2], fc;
    htr.getHistogramFibers(f[0], f[1]);

    for (int nf = 0; nf < 2; nf++) {
      if (f[nf] < 0 || (nf == 1 && f[0] == f[1]))
        continue;  // skip if invalid or the same
      for (fc = 0; fc <= 2; fc++) {
        HcalElectronicsId eid(fc, f[nf], spigot, dccid);
        eid.setHTR(htr_cr, htr_slot, htr_tb);
        DetId did = emap.lookup(eid);

        if (did.null() || did.det() != DetId::Hcal || did.subdetId() == 0) {
          if (unknownIds_.find(eid) == unknownIds_.end()) {
            edm::LogWarning("HCAL") << "HcalHistogramUnpacker: No match found for electronics id :" << eid;
            unknownIds_.insert(eid);
          }
          continue;
        }
        histoDigis.push_back(HcalHistogramDigi(HcalDetId(did)));  // add it!
        HcalHistogramDigi& digi = histoDigis.back();

        // unpack the four capids
        for (int capid = 0; capid < 4; capid++)
          htr.unpackHistogram(f[nf], fc, capid, digi.getArray(capid));
      }
    }
  }
}

void HcalUnpacker::unpack	(	const FEDRawData &	raw,
		const HcalElectronicsMap &	emap,
		Collections &	conts,
		HcalUnpackerReport &	report,
		bool	silent = false
	)

Definition at line 208 of file HcalUnpacker.cc.

References HcalDCCHeader::BOEshouldBeZeroAlways(), FEDRawData::data(), and FEDRawData::size().

                                       {
  if (raw.size() < 16) {
    if (!silent)
      edm::LogWarning("Invalid Data") << "Empty/invalid data, size = " << raw.size();
    return;
  }

  // get the DCC header
  const HcalDCCHeader* dccHeader = (const HcalDCCHeader*)(raw.data());

  if (dccHeader->BOEshouldBeZeroAlways() == 0)  // also includes uTCA before the common AMC13XG firmware
    unpackVME(raw, emap, colls, report, silent);
  else
    unpackUTCA(raw, emap, colls, report, silent);
}

void HcalUnpacker::unpackUMNio ( const FEDRawData &  raw, int  slot, Collections &  colls  )

private

Definition at line 1054 of file HcalUnpacker.cc.

References hcal::AMC13Header::AMCPayload(), hcal::AMC13Header::AMCSize(), hcal::AMC13Header::AMCSlot(), FEDRawData::data(), data, hcal::AMC13Header::NAMC(), and HcalUnpacker::Collections::umnio.

Referenced by setMode().

                                                                                  {
  const hcal::AMC13Header* amc13 = (const hcal::AMC13Header*)(raw.data());
  int namc = amc13->NAMC();
  //Find AMC corresponding to uMNio slot
  for (int iamc = 0; iamc < namc; iamc++) {
    if (amc13->AMCSlot(iamc) == slot)
      namc = iamc;
  }
  if (namc == amc13->NAMC()) {
    return;
  }
  const uint16_t* data = (const uint16_t*)(amc13->AMCPayload(namc));
  size_t nwords = amc13->AMCSize(namc) * (sizeof(uint64_t) / sizeof(uint16_t));
  *(colls.umnio) = HcalUMNioDigi(data, nwords);
}

void HcalUnpacker::unpackUTCA ( const FEDRawData &  raw, const HcalElectronicsMap &  emap, Collections &  conts, HcalUnpackerReport &  report, bool  silent = false  )

private

Definition at line 683 of file HcalUnpacker.cc.

References HcalDataFrameContainer< Digi >::addDataFrame(), hcal::AMC13Header::AMCCRCOk(), hcal::AMC13Header::AMCDataPresent(), hcal::AMC13Header::AMCEnabled(), hcal::AMC13Header::AMCId(), hcal::AMC13Header::AMCPayload(), hcal::AMC13Header::AMCSegmented(), hcal::AMC13Header::AMCSize(), hcal::AMC13Header::AMCSlot(), HcalUnpacker::Collections::calibCont, HcalCalibDetId::calibFlavor(), DetId::Calo, HcalUHTRData::const_iterator::channelid(), HcalUnpackerReport::countSpigotFormatError(), HcalUnpackerReport::countUnmappedDigi(), HcalUnpackerReport::countUnmappedTPDigi(), gather_cfg::cout, FEDRawData::data(), DetId::det(), runTauDisplay::eid, HcalUHTRData::const_iterator::flavor(), HcalUnpacker::Collections::hbheCont, DetId::Hcal, HcalBarrel, HcalCalibration, HcalEmpty, HcalEndcap, HcalForward, HcalOther, HcalOuter, HcalUnpacker::Collections::hfCont, HcalUnpacker::Collections::hoCont, mps_fire::i, triggerObjects_cff::id, HcalUHTRData::const_iterator::isHeader(), dqmiolumiharvest::j, HcalElectronicsMap::lookup(), HcalElectronicsMap::lookupTrigger(), hcal::AMC13Header::NAMC(), DetId::null(), HcalUnpacker::Collections::qie10, HcalUnpacker::Collections::qie10Addtl, HcalUnpacker::Collections::qie10Lasermon, HcalUnpacker::Collections::qie10ZDC, HcalUnpacker::Collections::qie11, HcalUnpacker::Collections::qie11Addtl, HcalUHTRData::const_iterator::raw(), HcalDataFrameContainer< Digi >::samples(), HcalUHTRData::const_iterator::soi(), hcal::AMC13Header::sourceId(), HcalOtherDetId::subdet(), HcalZDCDetId::SubdetectorId, DetId::subdetId(), HcalUHTRData::const_iterator::technicalDataType(), HcalUnpacker::Collections::tpCont, HcalTrigTowerDetId::Undefined, HcalUHTRData::const_iterator::value(), and HcalUnpacker::Collections::zdcCont.

Referenced by setMode().

                                           {
  const hcal::AMC13Header* amc13 = (const hcal::AMC13Header*)(raw.data());

  // how many AMC in this packet
  int namc = amc13->NAMC();
  for (int iamc = 0; iamc < namc; iamc++) {
    // if not enabled, ignore
    if (!amc13->AMCEnabled(iamc))
      continue;

    if (!amc13->AMCDataPresent(iamc)) {
      if (!silent)
        edm::LogWarning("Invalid Data") << "Missing data observed on iamc " << iamc << " of AMC13 with source id "
                                        << amc13->sourceId();
      report.countSpigotFormatError();
      continue;
    }
    if (!amc13->AMCCRCOk(iamc)) {
      if (!silent)
        edm::LogWarning("Invalid Data") << "CRC Error on uHTR data observed on iamc " << iamc
                                        << " of AMC13 with source id " << amc13->sourceId();
      report.countSpigotFormatError();
      //      continue;
    }
    // this unpacker cannot handle segmented data!
    if (amc13->AMCSegmented(iamc)) {
      if (!silent)
        edm::LogWarning("Invalid Data") << "Unpacker cannot handle segmented data observed on iamc " << iamc
                                        << " of AMC13 with source id " << amc13->sourceId();
      report.countSpigotFormatError();
      continue;
    }

    // ok, now we're work-able
    int slot = amc13->AMCSlot(iamc);
    int crate = amc13->AMCId(iamc) & 0xFF;

    HcalUHTRData uhtr(amc13->AMCPayload(iamc), amc13->AMCSize(iamc));
    //Check to make sure uMNio is not unpacked here
    if (uhtr.getFormatVersion() != 1) {
      unpackUMNio(raw, slot, colls);
      continue;
    }
#ifdef DebugLog
    //debug printouts
    int nwords = uhtr.getRawLengthBytes() / 2;
    for (int iw = 0; iw < nwords; iw++)
      printf("%04d %04x\n", iw, uhtr.getRawData16()[iw]);
#endif

    //use uhtr presamples since amc header not properly packed in simulation
    int nps = uhtr.presamples();

    HcalUHTRData::const_iterator i = uhtr.begin(), iend = uhtr.end();
    while (i != iend) {
#ifdef DebugLog
      std::cout << "This data is flavored:" << i.flavor() << std::endl;
#endif

      if (!i.isHeader()) {
        ++i;
#ifdef DebugLog
        std::cout << "its not a header" << std::endl;
#endif
        continue;
      }
      if (i.flavor() == 1 || i.flavor() == 0 || i.flavor() == 3) {
        int ifiber = ((i.channelid() >> 3) & 0x1F);
        int ichan = (i.channelid() & 0x7);
        HcalElectronicsId eid(crate, slot, ifiber, ichan, false);
        DetId did = emap.lookup(eid);
        // Count from current position to next header, or equal to end
        const uint16_t* head_pos = i.raw();
        int ns = 0;
        for (++i; i != iend && !i.isHeader(); ++i) {
          ns++;
        }
        // Check QEI11 container exists
        if (colls.qie11 == nullptr) {
          colls.qie11 = new QIE11DigiCollection(ns);
        } else if (colls.qie11->samples() != ns) {
          // if this sample type hasn't been requested to be saved
          // warn the user to provide a configuration that prompts it to be saved
          if (colls.qie11Addtl.find(ns) == colls.qie11Addtl.end()) {
            printInvalidDataMessage("QIE11", colls.qie11->samples(), ns, true);
          }
        }

        // Insert data
        if (!did.null()) {  // unpack and store...
          // only fill the default collection if we have the correct number of samples
          if (colls.qie11->samples() == ns) {
            colls.qie11->addDataFrame(did, head_pos);
          }
          // fill the additional qie11 collections
          if (colls.qie11Addtl.find(ns) != colls.qie11Addtl.end()) {
            colls.qie11Addtl[ns]->addDataFrame(did, head_pos);
          }
        } else {
          report.countUnmappedDigi(eid);
          if (unknownIds_.find(eid) == unknownIds_.end()) {
            if (!silent)
              edm::LogWarning("HCAL") << "HcalUnpacker: No match found for electronics id :" << eid;
            unknownIds_.insert(eid);
#ifdef DebugLog
            std::cout << "HcalUnpacker: No match found for electronics id :" << eid << std::endl;
#endif
          }
#ifdef DebugLog
          std::cout << "OH NO! detector id is null!" << std::endl;
#endif
        }
      } else if (i.flavor() == 2) {

        int ifiber = ((i.channelid() >> 3) & 0x1F);
        int ichan = (i.channelid() & 0x7);
        HcalElectronicsId eid(crate, slot, ifiber, ichan, false);
        DetId did = emap.lookup(eid);

        // Count from current position to next header, or equal to end
        const uint16_t* head_pos = i.raw();
        int ns = 0;
        for (++i; i != iend && !i.isHeader(); ++i) {
          ns++;
        }

        bool isZDC = (did.det() == DetId::Calo && did.subdetId() == HcalZDCDetId::SubdetectorId);
        bool isLasmon = (did.det() == DetId::Hcal && (HcalSubdetector)did.subdetId() == HcalOther &&
                         HcalCalibDetId(did).calibFlavor() == 5);

        if (isZDC) {
          if (colls.qie10ZDC == nullptr) {
            colls.qie10ZDC = new QIE10DigiCollection(ns);
          } else if (colls.qie10ZDC->samples() != ns) {
            printInvalidDataMessage("QIE10ZDC", colls.qie10ZDC->samples(), ns, false);
          }
        } else if (isLasmon) {
          if (colls.qie10Lasermon == nullptr) {
            colls.qie10Lasermon = new QIE10DigiCollection(ns);
          } else if (colls.qie10Lasermon->samples() != ns) {
            printInvalidDataMessage("QIE10LASMON", colls.qie10Lasermon->samples(), ns, false);
          }
        } else {  // these are the default qie10 channels
          if (colls.qie10 == nullptr) {
            colls.qie10 = new QIE10DigiCollection(ns);
          } else if (colls.qie10->samples() != ns) {
            // if this sample type hasn't been requested to be saved
            // warn the user to provide a configuration that prompts it to be saved
            if (colls.qie10Addtl.find(ns) == colls.qie10Addtl.end()) {
              printInvalidDataMessage("QIE10", colls.qie10->samples(), ns, true);
            }
          }
        }

        // Insert data
        if (!did.null()) {  // unpack and store...
          // fill the additional qie10 collections
          if (isZDC)
            colls.qie10ZDC->addDataFrame(did, head_pos);
          else if (isLasmon)
            colls.qie10Lasermon->addDataFrame(did, head_pos);
          else {
            // only fill the default collection if we have the correct number of samples
            if (colls.qie10->samples() == ns) {
              colls.qie10->addDataFrame(did, head_pos);
            }

            // fill the additional qie10 collections
            if (colls.qie10Addtl.find(ns) != colls.qie10Addtl.end()) {
              colls.qie10Addtl[ns]->addDataFrame(did, head_pos);
            }
          }
        } else {
          report.countUnmappedDigi(eid);
          if (unknownIds_.find(eid) == unknownIds_.end()) {
            if (!silent)
              edm::LogWarning("HCAL") << "HcalUnpacker: No match found for electronics id :" << eid;
            unknownIds_.insert(eid);
#ifdef DebugLog
            std::cout << "HcalUnpacker: No match found for electronics id :" << eid << std::endl;
#endif
          }
#ifdef DebugLog
          std::cout << "OH NO! HcalUnpacker: No match found for electronics id :" << eid << std::endl;
#endif
        }
      } else if (i.flavor() == 5 || (i.flavor() == 7 && i.technicalDataType() == 15)) {  // Old-style digis
        int ifiber = ((i.channelid() >> 2) & 0x1F);
        int ichan = (i.channelid() & 0x3);
        HcalElectronicsId eid(crate, slot, ifiber, ichan, false);
        DetId did = emap.lookup(eid);

        if (!did.null()) {  // unpack and store...
          if (did.det() == DetId::Calo && did.subdetId() == HcalZDCDetId::SubdetectorId) {
            colls.zdcCont->push_back(ZDCDataFrame(HcalZDCDetId(did)));
            HcalUnpacker_impl::unpack_compact<ZDCDataFrame>(
                i, iend, colls.zdcCont->back(), nps, eid, startSample_, endSample_);
          } else if (did.det() == DetId::Hcal) {
            switch (((HcalSubdetector)did.subdetId())) {
              case (HcalBarrel):
              case (HcalEndcap): {
                colls.hbheCont->push_back(HBHEDataFrame(HcalDetId(did)));
                HcalUnpacker_impl::unpack_compact<HBHEDataFrame>(
                    i, iend, colls.hbheCont->back(), nps, eid, startSample_, endSample_);
              } break;
              case (HcalOuter): {
                colls.hoCont->push_back(HODataFrame(HcalDetId(did)));
                HcalUnpacker_impl::unpack_compact<HODataFrame>(
                    i, iend, colls.hoCont->back(), nps, eid, startSample_, endSample_);
              } break;
              case (HcalForward): {
                colls.hfCont->push_back(HFDataFrame(HcalDetId(did)));
                HcalUnpacker_impl::unpack_compact<HFDataFrame>(
                    i, iend, colls.hfCont->back(), nps, eid, startSample_, endSample_);
              } break;
              case (HcalOther): {
                HcalOtherDetId odid(did);
                if (odid.subdet() == HcalCalibration) {
                  colls.calibCont->push_back(HcalCalibDataFrame(HcalCalibDetId(did)));
                  HcalUnpacker_impl::unpack_compact<HcalCalibDataFrame>(
                      i, iend, colls.calibCont->back(), nps, eid, startSample_, endSample_);
                }
              } break;
              case (HcalEmpty):
              default: {
                for (++i; i != iend && !i.isHeader(); ++i)
                  ;
              } break;
            }
          }
        } else {
          report.countUnmappedDigi(eid);
          if (unknownIds_.find(eid) == unknownIds_.end()) {
            if (!silent)
              edm::LogWarning("HCAL") << "HcalUnpacker: No match found for electronics id :" << eid;
            unknownIds_.insert(eid);
          }
          for (++i; i != iend && !i.isHeader(); ++i)
            ;
        }
      } else if (i.flavor() == 0x4) {  // TP digis
        int ilink = ((i.channelid() >> 4) & 0xF);
        int itower = (i.channelid() & 0xF);
        HcalElectronicsId eid(crate, slot, ilink, itower, true);
        DetId did = emap.lookupTrigger(eid);
#ifdef DebugLog
        std::cout << "Unpacking " << eid << " " << i.channelid() << std::endl;
#endif
        if (did.null()) {
          report.countUnmappedTPDigi(eid);
          if (unknownIdsTrig_.find(eid) == unknownIdsTrig_.end()) {
            if (!silent)
              edm::LogWarning("HCAL") << "HcalUnpacker: No trigger primitive match found for electronics id :" << eid;
            unknownIdsTrig_.insert(eid);
          }
          // Skip it
          for (++i; i != iend && !i.isHeader(); ++i)
            ;
        } else if (did == HcalTrigTowerDetId::Undefined || (did.det() == DetId::Hcal && did.subdetId() == 0)) {
          for (++i; i != iend && !i.isHeader(); ++i)
            ;
        } else {
          HcalTrigTowerDetId id(did);
#ifdef DebugLog
          std::cout << "Unpacking " << id << std::endl;
#endif
          colls.tpCont->push_back(HcalTriggerPrimitiveDigi(id));
          int j = 0;
          for (++i; i != iend && !i.isHeader(); ++i) {
            colls.tpCont->back().setSample(j, i.value());
            if (i.soi())
              colls.tpCont->back().setPresamples(j);
            j++;
          }
          colls.tpCont->back().setSize(j);
        }
      } else {
        // consume any not-understood channel data
        for (++i; i != iend && !i.isHeader(); ++i)
          ;
      }
    }
  }
}

void HcalUnpacker::unpackVME ( const FEDRawData &  raw, const HcalElectronicsMap &  emap, Collections &  conts, HcalUnpackerReport &  report, bool  silent = false  )

private

work through the samples

branch point between 2006-2011 data format and 2012+ data format

work through the samples

Definition at line 232 of file HcalUnpacker.cc.

References HcalUnpacker::Collections::calibCont, DetId::Calo, HcalHTRData::check(), HOUnrolledTP::checked, HcalUnpackerReport::countBusySpigot(), HcalUnpackerReport::countEmptyEventSpigot(), HcalUnpackerReport::countOFWSpigot(), HcalUnpackerReport::countSpigotFormatError(), HcalUnpackerReport::countUnmappedDigi(), HcalUnpackerReport::countUnmappedTPDigi(), FEDRawData::data(), HcalHTRData::dataPointers(), DetId::det(), runTauDisplay::eid, benchmark_cfg::fc, HcalQIESample::fiber(), HcalQIESample::fiberAndChan(), HcalQIESample::fiberChan(), HcalHTRData::FORMAT_VERSION_COMPACT_DATA, HcalDCCHeader::getDCCDataFormatVersion(), HcalHTRData::getFirmwareFlavor(), HcalHTRData::getFormatVersion(), HcalHTRData::getNPS(), HcalDTCHeader::getSlotCRCError(), HcalDTCHeader::getSlotData(), HcalDTCHeader::getSlotPresent(), HcalDCCHeader::getSourceId(), HcalDTCHeader::getSourceId(), HcalDCCHeader::getSpigotCRCError(), HcalDCCHeader::getSpigotData(), HcalDCCHeader::getSpigotPresent(), HcalHTRData::getSubmodule(), HcalUnpacker::Collections::hbheCont, DetId::Hcal, HcalBarrel, HcalCalibration, HcalEmpty, HcalEndcap, HcalForward, HcalOther, HcalOuter, HcalUnpacker::Collections::hfCont, HcalUnpacker::Collections::hoCont, mps_fire::i, triggerObjects_cff::id, LEDCalibrationChannels::ieta, HcalDetId::ieta(), HOUnrolledTP::ieta, LEDCalibrationChannels::iphi, HcalDetId::iphi(), HOUnrolledTP::iphi, HcalHTRData::is_channel_header(), HcalHTRData::isBusy(), HcalHTRData::isEmptyEvent(), HcalHTRData::isHistogramEvent(), HcalHTRData::isOverflowWarning(), isTPGSOI(), HcalHTRData::isUnsuppressed(), linear(), LogDebug, HcalElectronicsMap::lookup(), HcalElectronicsMap::lookupTrigger(), HcalDTCHeader::MAXIMUM_SLOT, DetId::null(), HcalTriggerPrimitiveSample::raw(), HcalQIESample::raw(), EgammaValidation_cff::samples, HOUnrolledTP::samples, HOUnrolledTP::setbit(), HcalElectronicsId::setHTR(), FEDRawData::size(), slb(), slbAndChan(), slbChan(), HOUnrolledTP::soi, HcalDCCHeader::SPIGOT_COUNT, HcalOtherDetId::subdet(), HcalZDCDetId::SubdetectorId, DetId::subdetId(), HcalUnpacker::Collections::tpCont, HcalUnpacker::Collections::tphoCont, HcalUnpacker::Collections::ttp, HcalTrigTowerDetId::Undefined, HcalTTPUnpacker::unpack(), HcalHTRData::unpack_per_channel_header(), validateGeometry_cfg::valid, HOUnrolledTP::valid, HcalHTRData::wasMarkAndPassZSTP(), testProducerWithPsetDescEmpty_cfi::x1, and HcalUnpacker::Collections::zdcCont.

Referenced by setMode().

                                          {
  // get the DCC header
  const HcalDCCHeader* dccHeader = (const HcalDCCHeader*)(raw.data());
  const HcalDTCHeader* dtcHeader = (const HcalDTCHeader*)(raw.data());
  bool is_VME_DCC = (dccHeader->getDCCDataFormatVersion() < 0x10) || ((mode_ & 0x1) == 0);

  int dccid =
      (is_VME_DCC) ? (dccHeader->getSourceId() - sourceIdOffset_) : (dtcHeader->getSourceId() - sourceIdOffset_);

  // check the summary status

  // walk through the HTR data.  For the uTCA, use spigot=slot+1
  HcalHTRData htr;
  const unsigned short *daq_first, *daq_last, *tp_first, *tp_last;
  const HcalQIESample *qie_begin, *qie_end, *qie_work;
  const HcalTriggerPrimitiveSample *tp_begin, *tp_end, *tp_work;
  for (int spigot = 0; spigot < HcalDCCHeader::SPIGOT_COUNT; spigot++) {
    if (is_VME_DCC) {
      if (!dccHeader->getSpigotPresent(spigot))
        continue;

      int retval = dccHeader->getSpigotData(spigot, htr, raw.size());
      if (retval != 0) {
        if (retval == -1) {
          if (!silent)
            edm::LogWarning("Invalid Data") << "Invalid HTR data (data beyond payload size) observed on spigot "
                                            << spigot << " of DCC with source id " << dccHeader->getSourceId();
          report.countSpigotFormatError();
        }
        continue;
      }
      // check
      if (dccHeader->getSpigotCRCError(spigot)) {
        if (!silent)
          edm::LogWarning("Invalid Data") << "CRC Error on HTR data observed on spigot " << spigot
                                          << " of DCC with source id " << dccHeader->getSourceId();
        report.countSpigotFormatError();
        continue;
      }
    } else {  // is_uTCA (!is_VME_DCC)
      int slot = spigot + 1;
      if (slot > HcalDTCHeader::MAXIMUM_SLOT)
        continue;

      if (!dtcHeader->getSlotPresent(slot))
        continue;

      int retval = dtcHeader->getSlotData(slot, htr, raw.size());
      if (retval != 0) {
        if (retval == -1) {
          if (!silent)
            edm::LogWarning("Invalid Data") << "Invalid uHTR data (data beyond payload size) observed on slot " << slot
                                            << " of DTC with source id " << dtcHeader->getSourceId();
          report.countSpigotFormatError();
        }
        continue;
      }
      // check
      if (dtcHeader->getSlotCRCError(slot)) {
        if (!silent)
          edm::LogWarning("Invalid Data") << "CRC Error on uHTR data observed on slot " << slot
                                          << " of DTC with source id " << dtcHeader->getSourceId();
        report.countSpigotFormatError();
        continue;
      }
    }

    // check for EE
    if (htr.isEmptyEvent()) {
      report.countEmptyEventSpigot();
    }
    if (htr.isOverflowWarning()) {
      report.countOFWSpigot();
    }
    if (htr.isBusy()) {
      report.countBusySpigot();
    }
    if (!htr.check()) {
      if (!silent)
        edm::LogWarning("Invalid Data") << "Invalid HTR data observed on spigot " << spigot << " of DCC with source id "
                                        << dccHeader->getSourceId();
      report.countSpigotFormatError();
      continue;
    }
    if (htr.isHistogramEvent()) {
      if (!silent)
        edm::LogWarning("Invalid Data") << "Histogram data passed to non-histogram unpacker on spigot " << spigot
                                        << " of DCC with source id " << dccHeader->getSourceId();
      continue;
    }
    if ((htr.getFirmwareFlavor() & 0xE0) == 0x80) {  // some kind of TTP data
      if (colls.ttp != nullptr) {
        HcalTTPUnpacker ttpUnpack;
        colls.ttp->push_back(HcalTTPDigi());
        ttpUnpack.unpack(htr, colls.ttp->back());
      } else {
        LogDebug("HcalTechTrigProcessor")
            << "Skipping data on spigot " << spigot << " of DCC with source id " << dccHeader->getSourceId()
            << " which is from the TechTrigProcessor (use separate unpacker!)";
      }
      continue;
    }
    if (htr.getFirmwareFlavor() >= 0x80) {
      if (!silent)
        edm::LogWarning("HcalUnpacker") << "Skipping data on spigot " << spigot << " of DCC with source id "
                                        << dccHeader->getSourceId() << " which is of unknown flavor "
                                        << htr.getFirmwareFlavor();
      continue;
    }

    // calculate "real" number of presamples
    int nps = htr.getNPS() - startSample_;

    // get pointers
    htr.dataPointers(&daq_first, &daq_last, &tp_first, &tp_last);
    unsigned int smid = htr.getSubmodule();
    int htr_tb = smid & 0x1;
    int htr_slot = (smid >> 1) & 0x1F;
    int htr_cr = (smid >> 6) & 0x1F;

    tp_begin = (const HcalTriggerPrimitiveSample*)tp_first;
    tp_end = (const HcalTriggerPrimitiveSample*)(tp_last + 1);  // one beyond last..

    int currFiberChan = 0x3F;  // invalid fiber+channel...
    int ncurr = 0;
    bool valid = false;

    bool tpgSOIbitInUse = htr.getFormatVersion() >= 3;                           // version 3 and later
    bool isHOtpg = htr.getFormatVersion() >= 3 && htr.getFirmwareFlavor() == 0;  // HO is flavor zero
    int npre = 0;
    /*
      Unpack the trigger primitives
    */
    if (isHOtpg) {
      HOUnrolledTP unrolled[24];
      for (tp_work = tp_begin; tp_work != tp_end; tp_work++) {
        if (tp_work->raw() == 0xFFFF)
          continue;  // filler word
        int sector = slbChan(tp_work->raw());
        if (sector > 2)
          continue;

        for (int ibit = 0; ibit < 8; ibit++) {
          int linear = sector * 8 + ibit;
          if (!unrolled[linear].checked) {
            unrolled[linear].checked = true;
            int fiber = (linear / 3) + 1;
            int fc = (linear % 3);
            // electronics id (use precision match for HO TP)
            HcalElectronicsId eid(fc, fiber, spigot, dccid);
            eid.setHTR(htr_cr, htr_slot, htr_tb);
            DetId did = emap.lookup(eid);
            if (!did.null()) {
              if (did.det() == DetId::Hcal && ((HcalSubdetector)did.subdetId()) == HcalOuter) {
                HcalDetId hid(did);
                unrolled[linear].valid = true;
                unrolled[linear].ieta = hid.ieta();
                unrolled[linear].iphi = hid.iphi();
              }
            } else {
              report.countUnmappedTPDigi(eid);
            }
          }
          if (unrolled[linear].valid) {
            if (isTPGSOI(*tp_work))
              unrolled[linear].soi = unrolled[linear].samples;
            if (tp_work->raw() & (1 << ibit))
              unrolled[linear].setbit(unrolled[linear].samples);
            unrolled[linear].samples++;
          }
        }
      }
      for (int i = 0; i < 24; i++) {
        if (unrolled[i].valid)
          colls.tphoCont->push_back(HOTriggerPrimitiveDigi(
              unrolled[i].ieta, unrolled[i].iphi, unrolled[i].samples, unrolled[i].soi, unrolled[i].databits));
      }
    } else {  // regular TPs (not HO)
      for (tp_work = tp_begin; tp_work != tp_end; tp_work++) {
        if (tp_work->raw() == 0xFFFF)
          continue;                                         // filler word
        if (slbAndChan(tp_work->raw()) != currFiberChan) {  // start new set
          npre = 0;
          currFiberChan = slbAndChan(tp_work->raw());
          // lookup the right channel
          HcalElectronicsId eid(slbChan(tp_work->raw()), slb(tp_work->raw()), spigot, dccid, htr_cr, htr_slot, htr_tb);
          DetId did = emap.lookupTrigger(eid);
          if (did.null()) {
            report.countUnmappedTPDigi(eid);
            if (unknownIdsTrig_.find(eid) == unknownIdsTrig_.end()) {
              if (!silent)
                edm::LogWarning("HCAL") << "HcalUnpacker: No trigger primitive match found for electronics id :" << eid;
              unknownIdsTrig_.insert(eid);
            }
            valid = false;
            continue;
          } else if (did == HcalTrigTowerDetId::Undefined || (did.det() == DetId::Hcal && did.subdetId() == 0)) {
            // known to be unmapped
            valid = false;
            continue;
          }
          HcalTrigTowerDetId id(did);
          colls.tpCont->push_back(HcalTriggerPrimitiveDigi(id));
          // set the various bits
          if (!tpgSOIbitInUse)
            colls.tpCont->back().setPresamples(nps);
          colls.tpCont->back().setZSInfo(htr.isUnsuppressed(),
                                         htr.wasMarkAndPassZSTP(slb(tp_work->raw()), slbChan(tp_work->raw())));

          // no hits recorded for current
          ncurr = 0;
          valid = true;
        }
        // add the word (if within settings or recent firmware [recent firmware ignores startSample/endSample])
        if (valid && ((tpgSOIbitInUse && ncurr < 10) || (ncurr >= startSample_ && ncurr <= endSample_))) {
          colls.tpCont->back().setSample(colls.tpCont->back().size(), *tp_work);
          colls.tpCont->back().setSize(colls.tpCont->back().size() + 1);
        }
        // set presamples,if SOI
        if (valid && tpgSOIbitInUse && isTPGSOI(*tp_work)) {
          colls.tpCont->back().setPresamples(ncurr);
        }
        ncurr++;
        npre++;
      }
    }

    if (htr.getFormatVersion() < HcalHTRData::FORMAT_VERSION_COMPACT_DATA) {
      qie_begin = (const HcalQIESample*)daq_first;
      qie_end = (const HcalQIESample*)(daq_last + 1);  // one beyond last..


      for (qie_work = qie_begin; qie_work != qie_end;) {
        if (qie_work->raw() == 0xFFFF) {
          qie_work++;
          continue;  // filler word
        }
        // always at the beginning ...

        // lookup the right channel
        HcalElectronicsId eid(qie_work->fiberChan(), qie_work->fiber(), spigot, dccid);
        eid.setHTR(htr_cr, htr_slot, htr_tb);
        DetId did = emap.lookup(eid);

        if (!did.null()) {
          if (did.det() == DetId::Calo && did.subdetId() == HcalZDCDetId::SubdetectorId) {
            colls.zdcCont->push_back(ZDCDataFrame(HcalZDCDetId(did)));
            qie_work = HcalUnpacker_impl::unpack<ZDCDataFrame>(qie_work,
                                                               qie_end,
                                                               colls.zdcCont->back(),
                                                               nps,
                                                               eid,
                                                               startSample_,
                                                               endSample_,
                                                               expectedOrbitMessageTime_,
                                                               htr);
          } else if (did.det() == DetId::Hcal) {
            switch (((HcalSubdetector)did.subdetId())) {
              case (HcalBarrel):
              case (HcalEndcap): {
                colls.hbheCont->push_back(HBHEDataFrame(HcalDetId(did)));
                qie_work = HcalUnpacker_impl::unpack<HBHEDataFrame>(qie_work,
                                                                    qie_end,
                                                                    colls.hbheCont->back(),
                                                                    nps,
                                                                    eid,
                                                                    startSample_,
                                                                    endSample_,
                                                                    expectedOrbitMessageTime_,
                                                                    htr);
              } break;
              case (HcalOuter): {
                colls.hoCont->push_back(HODataFrame(HcalDetId(did)));
                qie_work = HcalUnpacker_impl::unpack<HODataFrame>(qie_work,
                                                                  qie_end,
                                                                  colls.hoCont->back(),
                                                                  nps,
                                                                  eid,
                                                                  startSample_,
                                                                  endSample_,
                                                                  expectedOrbitMessageTime_,
                                                                  htr);
              } break;
              case (HcalForward): {
                colls.hfCont->push_back(HFDataFrame(HcalDetId(did)));
                qie_work = HcalUnpacker_impl::unpack<HFDataFrame>(qie_work,
                                                                  qie_end,
                                                                  colls.hfCont->back(),
                                                                  nps,
                                                                  eid,
                                                                  startSample_,
                                                                  endSample_,
                                                                  expectedOrbitMessageTime_,
                                                                  htr);
              } break;
              case (HcalOther): {
                HcalOtherDetId odid(did);
                if (odid.subdet() == HcalCalibration) {
                  colls.calibCont->push_back(HcalCalibDataFrame(HcalCalibDetId(did)));
                  qie_work = HcalUnpacker_impl::unpack<HcalCalibDataFrame>(qie_work,
                                                                           qie_end,
                                                                           colls.calibCont->back(),
                                                                           nps,
                                                                           eid,
                                                                           startSample_,
                                                                           endSample_,
                                                                           expectedOrbitMessageTime_,
                                                                           htr);
                }
              } break;
              case (HcalEmpty):
              default: {
                for (int fiberC = qie_work->fiberAndChan(); qie_work != qie_end && qie_work->fiberAndChan() == fiberC;
                     qie_work++)
                  ;
              } break;
            }
          }
        } else {
          report.countUnmappedDigi(eid);
          if (unknownIds_.find(eid) == unknownIds_.end()) {
            if (!silent)
              edm::LogWarning("HCAL") << "HcalUnpacker: No match found for electronics id :" << eid;
            unknownIds_.insert(eid);
          }
          for (int fiberC = qie_work->fiberAndChan(); qie_work != qie_end && qie_work->fiberAndChan() == fiberC;
               qie_work++)
            ;
        }
      }
    } else {
      // this is the branch for unpacking the compact data format with per-channel headers
      const unsigned short* ptr_header = daq_first;
      const unsigned short* ptr_end = daq_last + 1;
      int flavor, error_flags, capid0, channelid;

      while (ptr_header != ptr_end) {
        if (*ptr_header == 0xFFFF) {  // impossible filler word
          ptr_header++;
          continue;
        }
        // unpack the header word
        bool isheader = HcalHTRData::unpack_per_channel_header(*ptr_header, flavor, error_flags, capid0, channelid);
        if (!isheader) {
          ptr_header++;
          continue;
        }

        int fiberchan = channelid & 0x3;
        int fiber = ((channelid >> 2) & 0x7) + 1;

        // lookup the right channel
        HcalElectronicsId eid(fiberchan, fiber, spigot, dccid);
        eid.setHTR(htr_cr, htr_slot, htr_tb);
        DetId did = emap.lookup(eid);

        if (!did.null()) {
          if (did.det() == DetId::Calo && did.subdetId() == HcalZDCDetId::SubdetectorId) {
            colls.zdcCont->push_back(ZDCDataFrame(HcalZDCDetId(did)));
            ptr_header = HcalUnpacker_impl::unpack_compact<ZDCDataFrame>(ptr_header,
                                                                         ptr_end,
                                                                         colls.zdcCont->back(),
                                                                         nps,
                                                                         eid,
                                                                         startSample_,
                                                                         endSample_,
                                                                         expectedOrbitMessageTime_,
                                                                         htr);
          } else if (did.det() == DetId::Hcal) {
            switch (((HcalSubdetector)did.subdetId())) {
              case (HcalBarrel):
              case (HcalEndcap): {
                colls.hbheCont->push_back(HBHEDataFrame(HcalDetId(did)));
                ptr_header = HcalUnpacker_impl::unpack_compact<HBHEDataFrame>(ptr_header,
                                                                              ptr_end,
                                                                              colls.hbheCont->back(),
                                                                              nps,
                                                                              eid,
                                                                              startSample_,
                                                                              endSample_,
                                                                              expectedOrbitMessageTime_,
                                                                              htr);
              } break;
              case (HcalOuter): {
                colls.hoCont->push_back(HODataFrame(HcalDetId(did)));
                ptr_header = HcalUnpacker_impl::unpack_compact<HODataFrame>(ptr_header,
                                                                            ptr_end,
                                                                            colls.hoCont->back(),
                                                                            nps,
                                                                            eid,
                                                                            startSample_,
                                                                            endSample_,
                                                                            expectedOrbitMessageTime_,
                                                                            htr);
              } break;
              case (HcalForward): {
                colls.hfCont->push_back(HFDataFrame(HcalDetId(did)));
                ptr_header = HcalUnpacker_impl::unpack_compact<HFDataFrame>(ptr_header,
                                                                            ptr_end,
                                                                            colls.hfCont->back(),
                                                                            nps,
                                                                            eid,
                                                                            startSample_,
                                                                            endSample_,
                                                                            expectedOrbitMessageTime_,
                                                                            htr);
              } break;
              case (HcalOther): {
                HcalOtherDetId odid(did);
                if (odid.subdet() == HcalCalibration) {
                  colls.calibCont->push_back(HcalCalibDataFrame(HcalCalibDetId(did)));
                  ptr_header = HcalUnpacker_impl::unpack_compact<HcalCalibDataFrame>(ptr_header,
                                                                                     ptr_end,
                                                                                     colls.calibCont->back(),
                                                                                     nps,
                                                                                     eid,
                                                                                     startSample_,
                                                                                     endSample_,
                                                                                     expectedOrbitMessageTime_,
                                                                                     htr);
                }
              } break;
              case (HcalEmpty):
              default: {
                for (ptr_header++; ptr_header != ptr_end && !HcalHTRData::is_channel_header(*ptr_header); ptr_header++)
                  ;
              } break;
            }
          }
        } else {
          report.countUnmappedDigi(eid);
          if (unknownIds_.find(eid) == unknownIds_.end()) {
            if (!silent)
              edm::LogWarning("HCAL") << "HcalUnpacker: No match found for electronics id :" << eid;
            unknownIds_.insert(eid);
          }
          for (ptr_header++; ptr_header != ptr_end && !HcalHTRData::is_channel_header(*ptr_header); ptr_header++)
            ;
        }
      }
    }
  }
}

Member Data Documentation

int HcalUnpacker::endSample_

private

last sample from fed raw data to copy (if present)

Definition at line 85 of file HcalUnpacker.h.

int HcalUnpacker::expectedOrbitMessageTime_

private

Expected orbit bunch time (needed to evaluate time differences)

Definition at line 86 of file HcalUnpacker.h.

Referenced by setExpectedOrbitMessageTime().

int HcalUnpacker::mode_

private

Definition at line 87 of file HcalUnpacker.h.

Referenced by setMode().

int HcalUnpacker::nPrinted_

private

Definition at line 91 of file HcalUnpacker.h.

int HcalUnpacker::sourceIdOffset_

private

number to subtract from the source id to get the dcc id

Definition at line 83 of file HcalUnpacker.h.

int HcalUnpacker::startSample_

private

first sample from fed raw data to copy

Definition at line 84 of file HcalUnpacker.h.

std::set<HcalElectronicsId> HcalUnpacker::unknownIds_

private

Definition at line 88 of file HcalUnpacker.h.

std::set<HcalElectronicsId> HcalUnpacker::unknownIdsTrig_

private

Recorded to limit number of times a log message is generated.

Definition at line 88 of file HcalUnpacker.h.