mesytec_data.h

#ifndef MESYTEC_DATA_H
#define MESYTEC_DATA_H
 
#include <vector>
#include <string>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <cassert>
#include "mesytec_experimental_setup.h"
 
#define MESYTEC_DATA_NO_MDPP_NAMESPACE
#define MESYTEC_DATA_NO_PUBLIC_MEMBERS
 
namespace mesytec {
   const uint16_t mfm_frame_type = 0x4adf;
 
   class channel_data {
      uint32_t data_word;
      uint16_t data;
      uint8_t bus_number;
      uint8_t channel;
      bool ovflw;
      module::datatype_t data_type;
   public:
      channel_data() = default;
      ~channel_data() = default;
      channel_data(uint32_t _dw)
         : data_word{std::move(_dw)}
      {}
      channel_data(module::datatype_t _type, uint8_t _chan, uint16_t _data, uint32_t _dw, bool _ovflw=false)
         : data_type{_type}, data_word{_dw}, data{_data}, bus_number{0}, channel{_chan}, ovflw{_ovflw}
      {}
      channel_data(module::datatype_t _type, uint8_t _bus, uint8_t _chan, uint16_t _data, uint32_t _dw, bool _ovflw=false)
         : data_type{_type}, data_word{_dw}, data{_data}, bus_number{_bus}, channel{_chan}, ovflw{_ovflw}
      {}
      channel_data(channel_data&& other) = default;
      channel_data(const channel_data&) = delete;
      channel_data& operator=(const channel_data&) = delete;
      channel_data& operator=(channel_data&& other) = default;
      void ls(const mesytec::experimental_setup& cfg, uint8_t mod_id) const
      {
         auto& mod = cfg.get_module(mod_id);
         mod.set_data_word(data_word);
         mod.print_data();
      }
      void add_data_to_buffer(std::vector<uint32_t>& buf) const
      {
         buf.push_back(data_word);
      }
 
      uint32_t get_data_word() const
      {
         return data_word;
      }
      uint32_t get_data_word() const {…}
      uint16_t get_data() const
      {
         return data;
      }
      uint16_t get_data() const {…}
      bool get_overflow() const
      {
         return ovflw;
      }
      bool get_overflow() const {…}
      uint8_t get_bus_number() const
      {
         return bus_number;
      }
      uint8_t get_bus_number() const {…}
      uint8_t get_channel_number() const
      {
         return channel;
      }
      uint8_t get_channel_number() const {…}
      module::datatype_t get_data_type() const {
         return data_type;
      }
      module::datatype_t get_data_type() const  {…}
   };
   class channel_data {…};
 
   class module_data {
      friend class buffer_reader;
 
      std::vector<channel_data> data;
      uint32_t event_counter;
      uint32_t header_word;
      uint32_t eoe_word;
      uint16_t data_words; // number of data items + 1 EOE
      uint8_t module_id{UNKNOWN};
   public:
      void dump_module_data() const
      {
         std::cout << std::hex << std::showbase << header_word << std::endl;
         for (auto& v : data) std::cout << v.get_data_word() << std::endl;
      }
      void dump_module_data() const {…}
 
      uint32_t get_header_word() const
      {
         return header_word;
      }
 
      uint8_t get_module_id() const
      {
         return module_id;
      }
      uint8_t get_module_id() const {…}
      const std::vector<channel_data>& get_channel_data() const
      {
         return data;
      }
      const std::vector<channel_data>& get_channel_data() const {…}
      void clear()
      {
         data.clear();
         event_counter = 0;
         header_word = 0;
         data_words = 0;
         module_id = 0;
         eoe_word = 0;
      }
 
      uint16_t get_number_of_data_words() const
      {
         //assert(data_words);
         return data_words ? data_words - 1 : 0;
      }
      uint16_t get_number_of_data_words() const {…}
      void set_header_word(uint32_t _header_word, module& mod)
      {
         clear();
         header_word = _header_word;
         mod.set_data_word(_header_word);
         mod.set_infos_from_header_word();
         module_id = mod.id;
         data_words = mod.length_of_data();
         if (data_words) data.reserve(data_words); // max number of data words for 1 module
      }
 
      module_data() = default;
      ~module_data() = default;
      module_data(module_data&&) = default;
      module_data(const module_data&) = delete;
      module_data& operator=(const module_data&) = delete;
      module_data& operator=(module_data&&) = default;
      void add_data(module::datatype_t type, uint8_t channel, uint16_t datum, uint32_t data_word, bool ovflw=false)
      {
         data.emplace_back(type, channel, datum, data_word, ovflw);
      }
      void add_data(module::datatype_t type, uint8_t busnum, uint8_t channel, uint16_t datum, uint32_t data_word, bool ovflw=false)
      {
         data.emplace_back(type, busnum, channel, datum, data_word, ovflw);
      }
      void add_data(uint32_t data_word)
      {
         data.emplace_back(data_word);
      }
      void ls(const mesytec::experimental_setup& cfg) const
      {
         auto& mod = cfg.get_module(module_id);
         if (mod.is_mesytec_module()) {
            //std::cout << "  [data words:" << data.size() << "]\n";
            for (auto& d : data) d.ls(cfg, module_id);
         }
         else if (mod.is_mvlc_scaler()) {
            // 4 data words of 16 bits (least significant is first word) => 64 bit scaler
            assert(data.size() == 4);
            uint64_t x = 0;
            int i = 0;
            for (auto& d : data) x += ((uint64_t)d.get_data_word()) << (16 * (i++));
            std::cout << "mvlc_scaler::" << mod.name << " = " << std::hex << std::showbase << x << std::endl;
         }
         else
            std::cout << std::endl;
      }
      void add_data_to_buffer(std::vector<uint32_t>& buf) const
      {
         // reconstruct mesytec data buffer for this module i.e. series of 32 bit words
         //  HEADER - N x DATA  (in total, N+1 words)
         //
         // if no data words are present for the module, no data is added to buffer
         // (not even the header)
 
         if (data.size()) {
            buf.push_back(header_word);
            for (auto& v : data) v.add_data_to_buffer(buf);
         }
      }
      size_t size_of_buffer() const
      {
         // returns size (in 4-byte words) of buffer required to hold all data for this module
         // corresponding to header + N data words.
         //
         // if no data words are present for the module, this is 0
         return data.size() ? data.size() + 1 : 0;
      }
      bool has_data() const
      {
         return data.size() > 0;
      }
   };
   class module_data {…};
 
   class event {
      friend class buffer_reader;
 
      std::vector<module_data> modules;
      uint32_t event_counter = 0;
 
      bool with_tgv_timestamp = false;
      bool with_agava_timestamp = false;
      bool with_vtc_timestamp = false;
      uint16_t tgv_ts_lo{0}, tgv_ts_mid{0}, tgv_ts_hi{0};
      uint32_t agava_ts_lo{0}, agava_ts_hi{0};
      uint32_t vtc_ts_lo{0};
      uint16_t vtc_ts_hi{0};
      bool _is_scaler_event = false;
 
   public:
 
 
      uint32_t get_event_counter() const
      {
         return event_counter;
      }
      uint32_t get_event_counter() const {…}
      uint32_t& get_event_counter()
      {
         return event_counter;
      }
      uint32_t& get_event_counter() {…}
      event()
      {
         // reserve capacity for data from up to 25 modules (> capacity of 1 VME crate)
         // to avoid reallocations as data is 'pushed back' in to the vector
         modules.reserve(25);
      }
      void clear()
      {
         modules.clear();
         with_agava_timestamp=with_tgv_timestamp=_is_scaler_event=false;
         tgv_ts_lo = tgv_ts_mid = tgv_ts_hi = 0;
         agava_ts_hi = agava_ts_lo = 0;
         vtc_ts_hi = vtc_ts_lo = 0;
      }
      const std::vector<module_data>& get_module_data() const
      {
         return modules;
      }
      const std::vector<module_data>& get_module_data() const {…}
 
      void add_module_data(module_data& d)
      {
         modules.push_back(std::move(d));
      }
      bool is_full(unsigned int number_of_modules) const
      {
         return (modules.size() == number_of_modules);
      }
      void ls(const mesytec::experimental_setup& cfg) const
      {
         std::cout << " Event# " << event_counter << std::endl;
         for (auto& m : modules) m.ls(cfg);
      }
      size_t size_of_buffer() const
      {
         // returns size (in 4-byte words) of buffer required to hold all data for this event
         size_t s = 0;
         for (auto& v : modules) s += v.size_of_buffer();
         return s;
      }
      std::vector<uint32_t> get_output_buffer() const
      {
         // return full representation of all data for event
 
         std::vector<uint32_t> buf;
         buf.reserve(size_of_buffer());
         for (auto& m : modules) m.add_data_to_buffer(buf);
         return buf;
      }
      bool has_data() const
      {
         return modules.size() > 0;
      }
      bool get_with_tgv_timestamp() const
      {
          return with_tgv_timestamp;
      }
      void set_with_tgv_timestamp(const bool& _with_tgv_timestamp)
      {
          with_tgv_timestamp = _with_tgv_timestamp;
      }
      bool get_with_vtc_timestamp() const
      {
          return with_vtc_timestamp;
      }
      void set_with_vtc_timestamp(const bool& _with_vtc_timestamp)
      {
          with_vtc_timestamp = _with_vtc_timestamp;
      }
      bool get_with_agava_timestamp() const
      {
         return with_agava_timestamp;
      }
      void set_with_agava_timestamp(const bool& _with_agava_timestamp)
      {
         with_agava_timestamp = _with_agava_timestamp;
      }
      uint16_t get_tgv_ts_lo() const
      {
         return tgv_ts_lo;
      }
      void set_tgv_ts_lo(const uint16_t& _tgv_ts_lo)
      {
         tgv_ts_lo = _tgv_ts_lo;
      }
      uint16_t get_tgv_ts_mid() const
      {
         return tgv_ts_mid;
      }
      void set_tgv_ts_mid(const uint16_t& _tgv_ts_mid)
      {
         tgv_ts_mid = _tgv_ts_mid;
      }
      uint16_t get_tgv_ts_hi() const
      {
         return tgv_ts_hi;
      }
      void set_tgv_ts_hi(const uint16_t& _tgv_ts_hi)
      {
         tgv_ts_hi = _tgv_ts_hi;
      }
      uint32_t get_agava_ts_lo() const
      {
          return agava_ts_lo;
      }
      void set_agava_ts_lo(const uint32_t& _agava_ts_lo)
      {
          agava_ts_lo = _agava_ts_lo;
      }
      uint32_t get_agava_ts_hi() const
      {
          return agava_ts_hi;
      }
      void set_agava_ts_hi(const uint32_t& _agava_ts_hi)
      {
          agava_ts_hi = _agava_ts_hi;
      }
      uint32_t get_vtc_ts_lo() const
      {
          return vtc_ts_lo;
      }
      void set_vtc_ts_lo(const uint32_t& _vtc_ts_lo)
      {
          vtc_ts_lo = _vtc_ts_lo;
      }
      uint16_t get_vtc_ts_hi() const
      {
          return vtc_ts_hi;
      }
      void set_vtc_ts_hi(const uint16_t& _vtc_ts_hi)
      {
          vtc_ts_hi = _vtc_ts_hi;
      }
      bool is_scaler_event() const
      {
          // returns true if event ONLY contains scaler data
          return _is_scaler_event;
      }
      void set_is_scaler_event(bool newIs_scaler_event = true)
      {
          _is_scaler_event = newIs_scaler_event;
      }
   };
   class event {…};
}
#endif // READ_LISTFILE_H