daq_run.h

#pragma once
 
#include <stdio.h>
 
#include <fstream>
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
#include "pflib/Target.h"
#include "pflib/logging/Logging.h"
#include "pflib/packing/MultiSampleECONDEventPacket.h"
#include "pflib/packing/SingleROCEventPacket.h"
 
class DAQRunConsumer {
 public:
  virtual void start_run() {}
  virtual void end_run() {}
  virtual void consume(std::vector<uint32_t>& event) = 0;
  virtual ~DAQRunConsumer() = default;
};
 
void daq_run(pflib::Target* tgt, const std::string& cmd,
             DAQRunConsumer& consumer, int nevents, int rate = 100);
 
class WriteToBinaryFile : public DAQRunConsumer {
  std::string file_name_;
  FILE* fp_;
 
 public:
  WriteToBinaryFile(const std::string& file_name);
  ~WriteToBinaryFile();
  virtual void consume(std::vector<uint32_t>& event) final;
};
 
template <class EventPacket>
class DecodeAndWrite : public DAQRunConsumer {
 public:
  explicit DecodeAndWrite(int n_links);
  virtual ~DecodeAndWrite() = default;
  virtual void consume(std::vector<uint32_t>& event) final;
 
  virtual void write_event(const EventPacket& ep) = 0;
 
 protected:
  mutable ::pflib::logging::logger the_log_;
 
 private:
  EventPacket ep_;
};
 
template <class EventPacket>
class DecodeAndWriteToCSV : public DecodeAndWrite<EventPacket> {
  std::ofstream file_;
  std::function<void(std::ofstream&, const EventPacket&)> write_event_;
 
 public:
  DecodeAndWriteToCSV(
      const std::string& file_name,
      std::function<void(std::ofstream&)> write_header,
      std::function<void(std::ofstream&, const EventPacket&)> write_event,
      int n_links);
  virtual ~DecodeAndWriteToCSV() = default;
  virtual void write_event(const EventPacket& ep) final;
};
 
template <class EventPacket>
DecodeAndWriteToCSV<EventPacket> all_channels_to_csv(
    const std::string& file_name);
 
template <typename EventPacket>
class DecodeAndBuffer : public DecodeAndWrite<EventPacket> {
 public:
  DecodeAndBuffer(std::size_t nevents, int n_links);
  virtual ~DecodeAndBuffer() = default;
  const std::vector<EventPacket>& get_buffer() const;
  void set_buffer_size(std::size_t nevents);
  virtual void write_event(const EventPacket& ep) override;
  virtual void start_run() override;
 
 private:
  std::vector<EventPacket> ep_buffer_;
};