start outline of live decoding

looking at templating over DaqRunConsumer derived classes, getting complicated quickly unfortunately

Author: tomeichlersmith

app/tool/algorithm/level_pedestals.cxx

@@ -18,8 +18,9 @@
  * Calib and Common Mode channels are ignored.
  * TOT/TOA and the sample Tp/Tc flags are ignored.
  */
+template<class EventPacket>
 static std::array<int, 72> get_adc_medians(
-    const std::vector<pflib::packing::SingleROCEventPacket>& data) {
+    const std::vector<EventPacket>& data) {
   std::array<int, 72> medians;
   /// reserve a vector of the appropriate size to avoid repeating allocation
   /// time for all 72 channels

app/tool/daq.cxx

@@ -350,8 +350,34 @@ static void daq(const std::string& cmd, Target* pft) {
         pftool::readline_bool("Should we decode the packet into CSV?", true);
 
     if (decoding) {
-      DecodeAndWriteToCSV writer{all_channels_to_csv(fname + ".csv")};
-      daq_run(pft, cmd, writer, nevents, pftool::state.daq_rate);
+      std::unique_ptr<DaqRunConsumer> consumer;
+      switch(pftool::state.daq_format_mode) {
+        case Target::DaqFormat::ECOND_SW_HEADERS:
+          consumer = std::make_unique<DecodeAndWriteToCSV<pflib::packing::SoftWrappedECONDEventPacket>>(
+              fname+".csv",
+              [](std::ofstream& f) {
+                f << std::boolalpha;
+                f << pflib::packing::SoftWrappedECONDEventPacket::to_csv_header << '\n';
+              },
+              [](std::ofstream& f, const pflib::packing::SoftWrappedECONDEventPacket& ep) {
+                ep.to_csv(f);
+              });
+          break;
+        case Target::DaqFormat::SIMPLEROC:
+          consumer = std::make_unique<DecodeAndWriteToCSV<pflib::packing::SingleROCEventPacket>>(
+              fname+".csv",
+              [](std::ofstream& f) {
+                f << std::boolalpha;
+                f << pflib::packing::SingleROCEventPacket::to_csv_header << '\n';
+              },
+              [](std::ofstream& f, const pflib::packing::SingleROCEventPacket& ep) {
+                ep.to_csv(f);
+              });
+          break;
+        default:
+          PFEXCEPTION_RAISE("BadConf", "Unable to do live decoding for the currently configured format.");
+      }
+      daq_run(pft, cmd, *consumer, nevents, pftool::state.daq_rate);
     } else {
       WriteToBinaryFile writer{fname + ".raw"};
       daq_run(pft, cmd, writer, nevents, pftool::state.daq_rate);

app/tool/daq_run.cxx

@@ -77,7 +77,8 @@ void WriteToBinaryFile::consume(std::vector<uint32_t>& event) {
   fwrite(&(event[0]), sizeof(uint32_t), event.size(), fp_);
 }
 
-void DecodeAndWrite::consume(std::vector<uint32_t>& event) {
+template<class EventPacket>
+void DecodeAndWrite<EventPacket>::consume(std::vector<uint32_t>& event) {
   // we have to manually check the size so that we can do the reinterpret_cast
   if (event.size() == 0) {
     pflib_log(warn) << "event with zero words passed in, skipping";
@@ -91,58 +92,62 @@ void DecodeAndWrite::consume(std::vector<uint32_t>& event) {
   write_event(ep_);
 }
 
-DecodeAndWriteToCSV::DecodeAndWriteToCSV(
+template<class EventPacket>
+DecodeAndWriteToCSV<EventPacket>::DecodeAndWriteToCSV<EventPacket>(
     const std::string& file_name,
     std::function<void(std::ofstream&)> write_header,
-    std::function<void(std::ofstream& f,
-                       const pflib::packing::SingleROCEventPacket&)>
+    std::function<void(std::ofstream& f, const EventPacket&)>
         write_event)
-    : DecodeAndWrite(), file_{file_name}, write_event_{write_event} {
+    : DecodeAndWrite<EventPacket>(), file_{file_name}, write_event_{write_event} {
   if (not file_) {
     PFEXCEPTION_RAISE("FileOpen",
                       "unable to open " + file_name + " for writing");
   }
   write_header(file_);
 }
 
-void DecodeAndWriteToCSV::write_event(
-    const pflib::packing::SingleROCEventPacket& ep) {
+template<class EventPacket>
+void DecodeAndWriteToCSV<EventPacket>::write_event(const EventPacket& ep) {
   write_event_(file_, ep);
 }
 
-DecodeAndWriteToCSV all_channels_to_csv(const std::string& file_name) {
-  return DecodeAndWriteToCSV(
+template<class EventPacket>
+DecodeAndWriteToCSV<EventPacket> all_channels_to_csv(const std::string& file_name) {
+  return DecodeAndWriteToCSV<EventPacket>(
       file_name,
       [](std::ofstream& f) {
         f << std::boolalpha;
-        f << pflib::packing::SingleROCEventPacket::to_csv_header << '\n';
+        f << EventPacket::to_csv_header << '\n';
       },
-      [](std::ofstream& f, const pflib::packing::SingleROCEventPacket& ep) {
+      [](std::ofstream& f, const EventPacket& ep) {
         ep.to_csv(f);
       });
 }
 
-DecodeAndBuffer::DecodeAndBuffer(int nevents) : DecodeAndWrite() {
+template<class EventPacket>
+DecodeAndBuffer<EventPacket>::DecodeAndBuffer<EventPacket>(int nevents) : DecodeAndWrite<EventPacket>() {
   set_buffer_size(nevents);
 }
 
-void DecodeAndBuffer::write_event(
-    const pflib::packing::SingleROCEventPacket& ep) {
+template<class EventPacket>
+void DecodeAndBuffer<EventPacket>::write_event(const EventPacket& ep) {
   if (ep_buffer_.size() > ep_buffer_.capacity()) {
     pflib_log(warn) << "Trying to push more elements to buffer than allocated "
                        "capacity. Skipping!";
     return;
   }
   ep_buffer_.push_back(ep);
 }
+  
+template<class EventPacket>
+void DecodeAndBuffer<EventPacket>::start_run() { ep_buffer_.clear(); }
 
-void DecodeAndBuffer::start_run() { ep_buffer_.clear(); }
-
-const std::vector<pflib::packing::SingleROCEventPacket>&
-DecodeAndBuffer::get_buffer() const {
+template<class EventPacket>
+const std::vector<EventPacket>& DecodeAndBuffer<EventPacket>::get_buffer() const {
   return ep_buffer_;
 }
 
-void DecodeAndBuffer::set_buffer_size(int nevents) {
+template<class EventPacket>
+void DecodeAndBuffer<EventPacket>::set_buffer_size(int nevents) {
   ep_buffer_.reserve(nevents);
 }

app/tool/daq_run.h

@@ -55,6 +55,7 @@ class WriteToBinaryFile : public DAQRunConsumer {
  * other code just needs to write functions that define how the
  * decoded data should be written out.
  */
+template<class EventPacket>
 class DecodeAndWrite : public DAQRunConsumer {
  public:
   virtual ~DecodeAndWrite() = default;
@@ -65,43 +66,40 @@ class DecodeAndWrite : public DAQRunConsumer {
   virtual void consume(std::vector<uint32_t>& event) final;
 
   /// pure virtual function for writing out decoded event
-  virtual void write_event(const pflib::packing::SingleROCEventPacket& ep) = 0;
+  virtual void write_event(const EventPacket& ep) = 0;
 
  protected:
   /// logging for warning messages on empty events
   mutable ::pflib::logging::logger the_log_;
 
  private:
   /// event packet for decoding
-  pflib::packing::SingleROCEventPacket ep_;
+  EventPacket ep_;
 };
 
 /**
  * specializatin of DecodeAndWrite that holds a std::ofstream
  * for the user with functions for writing the header and events
  */
-class DecodeAndWriteToCSV : public DecodeAndWrite {
+template<class EventPacket>
+class DecodeAndWriteToCSV : public DecodeAndWrite<EventPacket> {
   /// output file writing to
   std::ofstream file_;
   /// function that writes row(s) to csv given an event
-  std::function<void(std::ofstream&,
-                     const pflib::packing::SingleROCEventPacket&)>
-      write_event_;
+  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 pflib::packing::SingleROCEventPacket&)>
-          write_event);
+      std::function<void(std::ofstream&, EventPacket&)> write_event);
   virtual ~DecodeAndWriteToCSV() = default;
   /// call write_event with our file handle
-  virtual void write_event(
-      const pflib::packing::SingleROCEventPacket& ep) final;
+  virtual void write_event(const EventPacket& ep) final;
 };
 
-DecodeAndWriteToCSV all_channels_to_csv(const std::string& file_name);
+template<class EventPacket>
+DecodeAndWriteToCSV<EventPacket> all_channels_to_csv(const std::string& file_name);
 
 /**
  * Consume an event packet, decode it, and save to buffer.
@@ -119,21 +117,21 @@ DecodeAndWriteToCSV all_channels_to_csv(const std::string& file_name);
  * const auto& events{buffer.get_buffer()};
  * ```
  */
-class DecodeAndBuffer : public DecodeAndWrite {
+template<typename EventPacket>
+class DecodeAndBuffer : public DecodeAndWrite<EventPacket> {
  public:
   DecodeAndBuffer(int nevents);
   virtual ~DecodeAndBuffer() = default;
   /// get buffer
-  const std::vector<pflib::packing::SingleROCEventPacket>& get_buffer() const;
+  const std::vector<EventPacket>& get_buffer() const;
   /// Set the buffer size
   void set_buffer_size(int nevents);
   /// Save to buffer
-  virtual void write_event(
-      const pflib::packing::SingleROCEventPacket& ep) override;
+  virtual void write_event(const EventPacket& ep) override;
   /// Check that the buffer was read and flushed since last run
   virtual void start_run() override;
 
  private:
   /// Buffer for event packets
-  std::vector<pflib::packing::SingleROCEventPacket> ep_buffer_;
+  std::vector<EventPacket> ep_buffer_;
 };