HcalRawDecoder.cxx

 
 
#include "Hcal/HcalRawDecoder.h"
 
#include <iomanip>
 
#include "Hcal/HcalDetectorMap.h"
 
// un comment for HcalRawDecoder-specific debug printouts to std::cout
// #define DEBUG
 
namespace hcal {
 
namespace utility {
 
class Reader {
  const std::vector<uint8_t>& buffer_;
  std::size_t i_word_;
  uint32_t next() {
    uint32_t w = buffer_.at(i_word_) | (buffer_.at(i_word_ + 1) << 8) |
                 (buffer_.at(i_word_ + 2) << 16) |
                 (buffer_.at(i_word_ + 3) << 24);
    i_word_ += 4;
    return w;
  }
 
 public:
  Reader(const std::vector<uint8_t>& b) : buffer_{b}, i_word_{0} {}
  operator bool() { return (i_word_ < buffer_.size()); }
  Reader& operator>>(uint32_t& w) {
    if (*this) w = next();
    return *this;
  }
};  // Reader
 
}  // namespace utility
 
namespace debug {
 
struct Hex {
  uint32_t word_;
  Hex(uint32_t w) : word_{w} {}
};
 
}  // namespace debug
 
inline std::ostream& operator<<(std::ostream& os, const debug::Hex& h) {
  os << "0x" << std::setfill('0') << std::setw(8) << std::hex << h.word_
     << std::dec;
  return os;
}
 
void PolarfireEventHeader::board(framework::Event& event,
                                 const std::string& prefix) {
  {
    event.add(prefix + "Version", version_);
    event.add(prefix + "FPGA", fpga_);
    event.add(prefix + "NSamples", nsamples_);
    event.add(prefix + "Spill", spill_);
    event.add(prefix + "Ticks", ticks_);
    event.add(prefix + "Bunch", bunch_);
    event.add(prefix + "Number", number_);
    event.add(prefix + "Run", run_);
    event.add(prefix + "DD", dd_);
    event.add(prefix + "MM", month_);
    event.add(prefix + "hh", hh_);
    event.add(prefix + "mm", mm_);
    event.add(prefix + "GoodLinkHeader", good_bxheader_);
    event.add(prefix + "GoodLinkTrailer", good_trailer_);
  }
}
 
void HcalRawDecoder::configure(framework::config::Parameters& ps) {
  input_file_ = ps.get<std::string>("input_file");
  input_names_ = ps.get<std::vector<std::string>>("input_names", {});
  input_pass_ = ps.get<std::string>("input_pass");
  output_name_ = ps.get<std::string>("output_name");
  roc_version_ = ps.get<int>("roc_version");
  translate_eid_ = ps.get<bool>("translate_eid");
  read_from_file_ = ps.get<bool>("read_from_file");
  detector_name_ = ps.get<std::string>("detector_name");
  if (read_from_file_) {
    file_reader_.open(input_file_);
  }
}
 
void HcalRawDecoder::beforeNewRun(ldmx::RunHeader& rh) {
  // if we are reading from a file, we need to provide the detector name
  if (read_from_file_) {
    rh.setDetectorName(detector_name_);
  }
}
 
void HcalRawDecoder::produce(framework::Event& event) {
  std::map<ldmx::HcalElectronicsID,
           std::vector<ldmx::HgcrocDigiCollection::Sample>>
      eid_to_samples;
  PolarfireEventHeader eh;
  if (read_from_file_) {
    if (!file_reader_ or file_reader_.eof()) return;
    eid_to_samples = this->read(file_reader_, eh);
  } else {
    for (const auto& name : input_names_) {
      hcal::utility::Reader bus_reader(
          event.getCollection<uint8_t>(name, input_pass_));
      auto single_pf_samples = this->read(bus_reader, eh);
      for (const auto& [id, samples] : single_pf_samples) {
        eid_to_samples[id] = samples;
      }
    }
  }
 
  eh.board(event, output_name_);
 
  ldmx::HgcrocDigiCollection digis;
  // assume all channels have same number of samples
  digis.setNumSamplesPerDigi(eid_to_samples.begin()->second.size());
  digis.setSampleOfInterestIndex(0);  // TODO configurable
  digis.setVersion(roc_version_);
  if (translate_eid_) {
#ifdef DEBUG
    std::cout << "Translating EIDs into DetIDs. Printing skipped EIDs..."
              << std::endl;
#endif
    auto detmap{
        getCondition<HcalDetectorMap>(HcalDetectorMap::CONDITIONS_OBJECT_NAME)};
    for (auto const& [eid, digi] : eid_to_samples) {
      // The electronics map returns an empty ID of the correct
      // type when the electronics ID is not found.
      //  need to check if the electronics ID exists
      //  TODO: do we want to end processing if this happens?
      if (detmap.exists(eid)) {
        uint32_t did_raw = detmap.get(eid).raw();
        digis.addDigi(did_raw, digi);
      } else {
#ifdef DEBUG
        std::cout << "EID(" << eid.fiber() << "," << eid.elink() << ","
                  << eid.channel() << ") ";
        for (auto& s : digi) std::cout << debug::hex(s.raw()) << " ";
        std::cout << std::endl;
#endif
      }
    }
  } else {
    for (auto const& [eid, digi] : eid_to_samples) {
      digis.addDigi(eid.raw(), digi);
    }
  }
 
#ifdef DEBUG
  std::cout << "adding " << digis.getNumDigis() << " digis each with "
            << digis.getNumSamplesPerDigi() << " samples to event bus"
            << std::endl;
#endif
  event.add(output_name_, digis);
  return;
}  // produce
 
}  // namespace hcal
DECLARE_PRODUCER(hcal::HcalRawDecoder);