datatypes.h

#ifndef PXAR_TYPES_H
#define PXAR_TYPES_H

#include "pxardllexport.h"

#if ((defined WIN32) && (defined __CINT__))
typedef int int32_t;
typedef short int int16_t;
typedef unsigned int uint32_t;
typedef unsigned short int uint16_t;
typedef unsigned char uint8_t;
#else
#include <stdint.h>
#endif

#include <iostream>
#include <vector>
#include <map>
#include <limits>
#include <cmath>

namespace pxar {

  class DLLEXPORT pixel {
  public:

  pixel() : _roc_id(0), _column(0), _row(0), _mean(0), _variance(0) {}

  pixel(uint8_t roc_id, uint8_t column, uint8_t row, double value) : _roc_id(roc_id), _column(column), _row(row), _variance(0) { setValue(value); }

  pixel(uint32_t rawdata, uint8_t rocid, bool invertAddress = false) : _roc_id(rocid) { decodeRaw(rawdata,invertAddress); }

    uint8_t roc() const { return _roc_id; };

    void setRoc(uint8_t roc) { _roc_id = roc; };

    uint8_t column() const { return _column; };

    void setColumn(uint8_t column) { _column = column; };

    uint8_t row() const { return _row; };

    void setRow(uint8_t row) { _row = row; };

    double variance() { return expandFloat(_variance); };

    void setVariance(double var) { _variance = compactFloat(var); };

    double value() { 
      return static_cast<double>(_mean);
    };

    void setValue(double val) { 
      _mean = static_cast<int16_t>(val);
    };

    bool operator == (const pixel& px) {
      return ((px.roc() == _roc_id )
          && (px.column() == _column)
          && (px.row() == _row));
    }

    bool operator < (const pixel& px) const {
      if(_roc_id == px.roc()) {
    if(_column == px.column()) {
      return _row < px.row();
    }
    return _column < px.column();
      }
      return _roc_id < px.roc();
    }

  private:
    uint8_t _roc_id;

    uint8_t _column;

    uint8_t _row;

    int16_t _mean;

    uint16_t _variance;

    void decodeRaw(uint32_t raw, bool invert);

    uint16_t compactFloat(double input) {
      return static_cast<uint16_t>(round(input*std::numeric_limits<uint16_t>::max()));
    }

    double expandFloat(uint16_t input) {
      return static_cast<double>(input)/std::numeric_limits<uint16_t>::max();
    }

    friend std::ostream & operator<<(std::ostream &out, pixel& px) {
      out << "ROC " << static_cast<int>(px.roc())
      << " [" << static_cast<int>(px.column()) << "," << static_cast<int>(px.row()) 
      << "," << static_cast<double>(px.value()) << "]";
      return out;
    }
  };

  class DLLEXPORT Event {
  public:
    Event() : header(0), trailer(0), pixels() {}
    void Clear() { header = 0; trailer = 0; pixels.clear();}
    uint16_t header;
    uint16_t trailer;
    std::vector<pixel> pixels;
  private:
    friend std::ostream & operator<<(std::ostream &out, Event& evt) {
      out << "====== " << std::hex << static_cast<uint16_t>(evt.header) << std::dec << " ====== ";
      for (std::vector<pixel>::iterator it = evt.pixels.begin(); it != evt.pixels.end(); ++it)
    out << (*it) << " ";
      return out;
    }
  };


  class DLLEXPORT rawEvent {
  public:
  rawEvent() : data(), flags(0) {}
    void SetStartError() { flags |= 1; }
    void SetEndError()   { flags |= 2; }
    void SetOverflow()   { flags |= 4; }
    void ResetStartError() { flags &= static_cast<unsigned int>(~1); }
    void ResetEndError()   { flags &= static_cast<unsigned int>(~2); }
    void ResetOverflow()   { flags &= static_cast<unsigned int>(~4); }
    void Clear() { flags = 0; data.clear(); }
    bool IsStartError() { return (flags & 1) != 0; }
    bool IsEndError()   { return (flags & 2) != 0; }
    bool IsOverflow()   { return (flags & 4) != 0; }
    
    size_t GetSize() { return data.size(); }
    void Add(uint16_t value) { data.push_back(value); }
    uint16_t operator[](size_t index) { return data.at(index); }

    std::vector<uint16_t> data;

  private:
    /*
      bit 0 = misaligned start
      bit 1 = no end detected
      bit 2 = overflow
    */
    unsigned int flags;

    friend std::ostream & operator<<(std::ostream &out, rawEvent& record) {
      out << "====== " << std::hex << static_cast<uint16_t>(record.flags) << std::dec << " ====== ";
      for (std::vector<uint16_t>::iterator it = record.data.begin(); it != record.data.end(); ++it)
    out << std::hex << (*it) << std::dec << " ";
      return out;
    }
  };

  class DLLEXPORT pixelConfig {
  public:
  pixelConfig() : 
    _column(0), _row(0), 
      _trim(15), _mask(true), _enable(false) {}
  pixelConfig(uint8_t column, uint8_t row, uint8_t trim, bool mask = true, bool enable = false) : 
    _column(column), _row(row), _trim(trim),
      _mask(mask), _enable(enable) {}
    uint8_t column() const { return _column; }
    void setColumn(uint8_t column) { _column = column; }
    uint8_t row() const { return _row; }
    void setRow(uint8_t row) { _row = row; }
    uint8_t roc() const { return _roc_id; }
    void setRoc(uint8_t roc) { _roc_id = roc; }
    uint8_t trim() const { return _trim; }
    void setTrim(uint8_t trim) { _trim = trim; }
    bool mask() const { return _mask; }
    void setMask(bool mask) { _mask = mask; }
    bool enable() const { return _enable; }
    void setEnable(bool enable) { _enable = enable; }
  private:
    uint8_t _column;
    uint8_t _row;
    uint8_t _roc_id;
    uint8_t _trim;
    bool _mask;
    bool _enable;
  };

  class DLLEXPORT rocConfig {
  public:
  rocConfig() : pixels(), dacs(), type(0), _enable(true) {}
    std::vector< pixelConfig > pixels;
    std::map< uint8_t,uint8_t > dacs;
    uint8_t type;
    uint8_t i2c_address;
    bool enable() const { return _enable; }
    void setEnable(bool enable) { _enable = enable; }
  private:
    bool _enable;
  };

  class DLLEXPORT tbmConfig {
  public:
  tbmConfig() : dacs(), type(0), enable(true) {}
    std::map< uint8_t,uint8_t > dacs;
    uint8_t type;
    bool enable;
  };

  class DLLEXPORT statistics {
    friend class dtbEventDecoder;

  public:
  statistics() :
    m_errors_event_start(0),
      m_errors_event_stop(0),
      m_errors_event_overflow(0),
      m_errors_event_invalid_words(0),
      m_errors_event_invalid_xor(0),
      m_errors_tbm_header(0),
      m_errors_tbm_trailer(0),
      m_errors_tbm_eventid_mismatch(0),
      m_errors_roc_missing(0),
      m_errors_roc_readback(0),
      m_errors_pixel_address(0),
      m_errors_pixel_pulseheight(0),
      m_errors_pixel_buffer_corrupt(0)
    {};
    // Print all statistics to stdout:
    void dump();
    friend statistics& operator+=(statistics &lhs, const statistics &rhs);

    uint32_t info_words_read() {return m_info_words_read; }
    uint32_t info_pixels_valid() {return m_info_pixels_valid; }

    uint32_t errors() {
      return (errors_pixel() + errors_tbm() + errors_roc() + errors_event());
    };
    uint32_t errors_event() {
      return (errors_event_start()
          + errors_event_stop()
          + errors_event_overflow()
          + errors_event_invalid_words()
          + errors_event_invalid_xor());
    };
    uint32_t errors_tbm() {
      return (errors_tbm_header()
          + errors_tbm_trailer()
          + errors_tbm_eventid_mismatch());
    };
    uint32_t errors_roc() {
      return (errors_roc_missing()
          + errors_roc_readback());
    };
    uint32_t errors_pixel() { 
      return (errors_pixel_incomplete()
          + errors_pixel_address()
          + errors_pixel_pulseheight()
          + errors_pixel_buffer_corrupt());
    };
    uint32_t errors_event_start() { return m_errors_event_start; }
    uint32_t errors_event_stop() { return m_errors_event_stop; }
    uint32_t errors_event_overflow() { return m_errors_event_overflow; }
    uint32_t errors_event_invalid_words() { return m_errors_event_invalid_words; }
    uint32_t errors_event_invalid_xor() { return m_errors_event_invalid_xor; }
    uint32_t errors_tbm_header() { return m_errors_tbm_header; }
    uint32_t errors_tbm_eventid_mismatch() { return m_errors_tbm_eventid_mismatch; }
    uint32_t errors_tbm_trailer() { return m_errors_tbm_trailer; }
    uint32_t errors_roc_missing() { return m_errors_roc_missing; }
    uint32_t errors_roc_readback() { return m_errors_roc_readback; }
    uint32_t errors_pixel_incomplete() { return m_errors_pixel_incomplete; }
    uint32_t errors_pixel_address() { return m_errors_pixel_address; };
    uint32_t errors_pixel_pulseheight() { return m_errors_pixel_pulseheight; };
    uint32_t errors_pixel_buffer_corrupt() { return m_errors_pixel_buffer_corrupt; };
  private:
    // Clear all statistics:
    void clear();

    // Total number of words read:
    uint32_t m_info_words_read;
    // Total number of empty events (no pixel hit):
    //uint32_t m_info_events_empty;
    // Total number of valid events (with pixel hits):
    //uint32_t m_info_events_valid;
    // Total number of pixel hits:
    uint32_t m_info_pixels_valid;

    // Total number of events with misplaced start
    uint32_t m_errors_event_start;
    // Total number of events with misplaced stop:
    uint32_t m_errors_event_stop;
    // Total number of events with data overflow:
    uint32_t m_errors_event_overflow;
    // Total number of invalid 5bit words detected by DESER400:
    uint32_t m_errors_event_invalid_words;
    // Total number of events with invalid XOR eye diagram:
    uint32_t m_errors_event_invalid_xor;

    // Total number of events with flawed TBM header:
    uint32_t m_errors_tbm_header;
    // Total number of events with flawed TBM trailer:
    uint32_t m_errors_tbm_trailer;
    // Total number of event ID mismatches in the datastream:
    uint32_t m_errors_tbm_eventid_mismatch;

    // Total number of events with missing ROC header(s):
    uint32_t m_errors_roc_missing;
    // Total number of misplaced ROC readback start markers:
    uint32_t m_errors_roc_readback;

    // Total number of undecodable pixels (data missing)
    uint32_t m_errors_pixel_incomplete;
    // Total number of undecodable pixels (by address)
    uint32_t m_errors_pixel_address;
    // Total number of undecodable pixels (by pulse height fill bit)
    uint32_t m_errors_pixel_pulseheight;
    // Total number of pixels with row 80:
    uint32_t m_errors_pixel_buffer_corrupt;
  };
}
#endif