lasp_daqdata.h

Go to the documentation of this file.

#pragma once
#include "lasp_daqconfig.h"
#include "lasp_types.h"
#include <armadillo>
#include <cassert>
#include <functional>
#include <gsl/gsl-lite.hpp>
#include <memory>
#include <type_traits>
 
class Daq;
 
using byte_t = char;
 
class DaqData {
protected:
  byte_t *_data;
 
public:
  us nframes;
 
  us nchannels;
 
  DataTypeDescriptor::DataType dtype;
 
  DataTypeDescriptor dtype_descr;
 
  us sw;
 
  DaqData(const us nframes, const us nchannels,
          const DataTypeDescriptor::DataType dtype);
  DaqData(const DaqData &);
  DaqData(DaqData &&);
  DaqData &operator=(const DaqData &) = delete;
  ~DaqData();
 
  byte_t *raw_ptr(const us frame = 0, const us channel = 0) {
    assert(frame < nframes);
    assert(channel < nchannels);
    return &(_data[sw * (frame + channel * nframes)]);
  }
  const byte_t *raw_ptr(const us frame = 0, const us channel = 0) const {
    assert(frame < nframes);
    assert(channel < nchannels);
    return &(_data[sw * (frame + channel * nframes)]);
  }
 
  us size_bytes() const { return sw * nchannels * nframes; }
 
  void copyInFromRaw(const std::vector<byte_t *> &ptrs);
 
  void copyInFromRaw(const us channel, const byte_t *ptr);
 
  void copyToRaw(const us channel, byte_t *ptr);
 
  arma::Mat<d> toFloat() const;
 
  arma::Col<d> toFloat(const us channel_no) const;
 
  d toFloat(const us frame_no, const us channel_no) const;
 
  void fromFloat(const us frame_no, const us channel_no,
                 const d data);
 
  void fromFloat(const us channel, const arma::Col<d> &data);
 
  //  Return value based on type
  template <typename T> T &value(const us frame, const us channel) {
#if LASP_DEBUG == 1
    check_type<T>();
#endif
    return *reinterpret_cast<T *>(raw_ptr(frame, channel));
  }
  template <typename T> const T &value(const us frame, const us channel) const {
#if LASP_DEBUG == 1
    check_type<T>();
#endif
    return *reinterpret_cast<const T *>(raw_ptr(frame, channel));
  }
 
  void print() const;
 
protected:
  template <typename T> void check_type() const {
    using DataType = DataTypeDescriptor::DataType;
 
    bool correct = false;
    static_assert(std::is_arithmetic<T>::value);
 
    if constexpr (std::is_floating_point<T>::value) {
      correct |= sizeof(T) == 4 && dtype == DataType::dtype_fl32;
      correct |= sizeof(T) == 8 && dtype == DataType::dtype_fl64;
 
    } else {
      correct |= sizeof(T) == 1 && dtype == DataType::dtype_int8;
      correct |= sizeof(T) == 2 && dtype == DataType::dtype_int16;
      correct |= sizeof(T) == 4 && dtype == DataType::dtype_int32;
    }
    if (!correct) {
      throw std::runtime_error("Wrong datatype for template argument");
    }
  }
 
  template <typename T> arma::Mat<d> toFloat() const;
  template <typename T> arma::Col<d> toFloat(const us channel_no) const;
  template <typename T> d toFloat(const us frame_no, const us channel_no) const;
 
  /* template <typename T> void fromFloat(const dmat&); */
  template <typename T>
  void fromFloat(const us channel_no, const arma::Col<d> &vals);
  template <typename T>
  void fromFloat(const us frame_no, const us channel_no, const d val);
};