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/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;
};
 
class DecodeAndWrite : public DAQRunConsumer {
 public:
  virtual ~DecodeAndWrite() = default;
  virtual void consume(std::vector<uint32_t>& event) final;
 
  virtual void write_event(const pflib::packing::SingleROCEventPacket& ep) = 0;
 
 protected:
  mutable ::pflib::logging::logger the_log_;
 
 private:
  pflib::packing::SingleROCEventPacket ep_;
};
 
class DecodeAndWriteToCSV : public DecodeAndWrite {
  std::ofstream file_;
  std::function<void(std::ofstream&,
                     const pflib::packing::SingleROCEventPacket&)>
      write_event_;
 
 public:
  DecodeAndWriteToCSV(
      const std::string& file_name,
      std::function<void(std::ofstream&)> write_header,
      std::function<void(std::ofstream&,
                         const pflib::packing::SingleROCEventPacket&)>
          write_event);
  virtual ~DecodeAndWriteToCSV() = default;
  virtual void write_event(
      const pflib::packing::SingleROCEventPacket& ep) final;
};
 
DecodeAndWriteToCSV all_channels_to_csv(const std::string& file_name);
 
class DecodeAndBuffer : public DecodeAndWrite {
 public:
  DecodeAndBuffer(int nevents);
  virtual ~DecodeAndBuffer() = default;
  const std::vector<pflib::packing::SingleROCEventPacket>& get_buffer() const;
  void set_buffer_size(int nevents);
  virtual void write_event(
      const pflib::packing::SingleROCEventPacket& ep) override;
  virtual void start_run() override;
 
 private:
  std::vector<pflib::packing::SingleROCEventPacket> ep_buffer_;
};