SiStripRawToDigiUnpacker.h

Go to the documentation of this file.

#ifndef EventFilter_SiStripRawToDigi_SiStripRawToDigiUnpacker_H
#define EventFilter_SiStripRawToDigi_SiStripRawToDigiUnpacker_H

#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/DetSetVector.h"
#include "DataFormats/DetId/interface/DetIdCollection.h"
#include "DataFormats/SiStripCommon/interface/SiStripConstants.h"
#include "EventFilter/SiStripRawToDigi/interface/SiStripFEDBuffer.h"
#include "FWCore/Utilities/interface/Visibility.h"
#include "WarningSummary.h"

namespace sistrip {
  class RawToClustersLazyUnpacker;
}
namespace sistrip {
  class RawToDigiUnpacker;
}

class FEDRawDataCollection;
class FEDRawData;
class SiStripDigi;
class SiStripRawDigi;
class SiStripEventSummary;
class SiStripFedCabling;

namespace sistrip {

  class dso_hidden RawToDigiUnpacker {
    friend class RawToClustersLazyUnpacker;

  public:
    typedef edm::DetSetVector<SiStripDigi> Digis;
    typedef edm::DetSetVector<SiStripRawDigi> RawDigis;

    RawToDigiUnpacker(int16_t appended_bytes,
                      int16_t fed_buffer_dump_freq,
                      int16_t fed_event_dump_freq,
                      int16_t trigger_fed_id,
                      bool using_fed_key,
                      bool unpack_bad_channels,
                      bool mark_missing_feds,
                      const uint32_t errorThreshold);

    RawToDigiUnpacker() = delete;

    ~RawToDigiUnpacker();

    void createDigis(const SiStripFedCabling&,
                     const FEDRawDataCollection&,
                     SiStripEventSummary&,
                     RawDigis& scope_mode,
                     RawDigis& virgin_raw,
                     RawDigis& proc_raw,
                     Digis& zero_suppr,
                     DetIdCollection&,
                     RawDigis& common_mode);

    void triggerFed(const FEDRawDataCollection&, SiStripEventSummary&, const uint32_t& event);

    void locateStartOfFedBuffer(const uint16_t& fed_id, const FEDRawData& input, FEDRawData& output);

    inline void quiet(bool);

    inline void useDaqRegister(bool);

    inline void extractCm(bool);

    inline void doFullCorruptBufferChecks(bool);

    inline void doAPVEmulatorCheck(bool);

    inline void legacy(bool);

    void printWarningSummary() const { warnings_.printSummary(); }

  private:
    void update(
        RawDigis& scope_mode, RawDigis& virgin_raw, RawDigis& proc_raw, Digis& zero_suppr, RawDigis& common_mode);

    void updateEventSummary(const sistrip::FEDBuffer&, SiStripEventSummary&);

    inline void readoutOrder(uint16_t& physical_order, uint16_t& readout_order);

    inline void physicalOrder(uint16_t& readout_order, uint16_t& physical_order);

    inline sistrip::FedBufferFormat fedBufferFormat(const uint16_t& register_value);

    inline sistrip::FedReadoutMode fedReadoutMode(const uint16_t& register_value);

    static void dumpRawData(uint16_t fed_id, const FEDRawData&, std::stringstream&);

    void cleanupWorkVectors();

    class Registry {
    public:
      Registry(uint32_t aDetid, uint16_t firstStrip, size_t indexInVector, uint16_t numberOfDigis)
          : detid(aDetid), first(firstStrip), index(indexInVector), length(numberOfDigis) {}
      bool operator<(const Registry& other) const {
        return (detid != other.detid ? detid < other.detid : first < other.first);
      }
      uint32_t detid;
      uint16_t first;
      size_t index;
      uint16_t length;
    };

    int16_t headerBytes_;
    int16_t fedBufferDumpFreq_;
    int16_t fedEventDumpFreq_;
    int16_t triggerFedId_;
    bool useFedKey_;
    bool unpackBadChannels_;
    bool markMissingFeds_;

    uint32_t event_;
    bool once_;
    bool first_;
    bool useDaqRegister_;
    bool quiet_;
    bool extractCm_;
    bool doFullCorruptBufferChecks_;
    bool doAPVEmulatorCheck_;
    bool legacy_;
    uint32_t errorThreshold_;

    std::vector<Registry> zs_work_registry_;
    std::vector<Registry> virgin_work_registry_;
    std::vector<Registry> scope_work_registry_;
    std::vector<Registry> proc_work_registry_;
    std::vector<Registry> cm_work_registry_;

    std::vector<SiStripDigi> zs_work_digis_;
    std::vector<SiStripRawDigi> virgin_work_digis_;
    std::vector<SiStripRawDigi> scope_work_digis_;
    std::vector<SiStripRawDigi> proc_work_digis_;
    std::vector<SiStripRawDigi> cm_work_digis_;

    WarningSummary warnings_;
  };
}  // namespace sistrip

void sistrip::RawToDigiUnpacker::readoutOrder(uint16_t& physical_order, uint16_t& readout_order) {
  readout_order = (4 * ((static_cast<uint16_t>((static_cast<float>(physical_order) / 8.0))) % 4) +
                   static_cast<uint16_t>(static_cast<float>(physical_order) / 32.0) + 16 * (physical_order % 8));
}

void sistrip::RawToDigiUnpacker::physicalOrder(uint16_t& readout_order, uint16_t& physical_order) {
  physical_order = ((32 * (readout_order % 4)) + (8 * static_cast<uint16_t>(static_cast<float>(readout_order) / 4.0)) -
                    (31 * static_cast<uint16_t>(static_cast<float>(readout_order) / 16.0)));
}

sistrip::FedBufferFormat sistrip::RawToDigiUnpacker::fedBufferFormat(const uint16_t& register_value) {
  if ((register_value & 0xF) == 0x1) {
    return sistrip::FULL_DEBUG_FORMAT;
  } else if ((register_value & 0xF) == 0x2) {
    return sistrip::APV_ERROR_FORMAT;
  } else if ((register_value & 0xF) == 0x0) {
    return sistrip::UNDEFINED_FED_BUFFER_FORMAT;
  } else {
    return sistrip::UNKNOWN_FED_BUFFER_FORMAT;
  }
}

sistrip::FedReadoutMode sistrip::RawToDigiUnpacker::fedReadoutMode(const uint16_t& register_value) {
  return static_cast<sistrip::FedReadoutMode>(register_value & 0xF);
}

void sistrip::RawToDigiUnpacker::quiet(bool quiet) { quiet_ = quiet; }

void sistrip::RawToDigiUnpacker::useDaqRegister(bool use) { useDaqRegister_ = use; }

void sistrip::RawToDigiUnpacker::extractCm(bool extract_cm) { extractCm_ = extract_cm; }

void sistrip::RawToDigiUnpacker::doFullCorruptBufferChecks(bool do_full_corrupt_buffer_checks) {
  doFullCorruptBufferChecks_ = do_full_corrupt_buffer_checks;
}

void sistrip::RawToDigiUnpacker::doAPVEmulatorCheck(bool do_APVEmulator_check) {
  doAPVEmulatorCheck_ = do_APVEmulator_check;
}

void sistrip::RawToDigiUnpacker::legacy(bool legacy) { legacy_ = legacy; }

#endif  // EventFilter_SiStripRawToDigi_SiStripRawToDigiUnpacker_H