dataitem.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <cinttypes>
#include <cstdio>
#include <cstring>
 
namespace pottu
{
 
    enum class itemtype_e : uint32_t
    {
    tracedata = 0,
    tracehead = 1,
    info = 2,
    data = 3
    };
 
    inline const char *rectypeToString(uint64_t type)
    {
    static const char *tbl[] = {"tracedata", "tracehead", "info", "data", "INVALID"};
    return tbl[type < 4 ? type : 4];
    }
 
    enum class infocode_e : uint32_t
    {
    undef = 0,
    pileup = 1,
    pausets = 2,
    resumets = 3,
    sync100ts = 4,
    undef2 = 5,
    discrdata = 6,
    extendedts = 7,
    st_mbs_info = 8,
    adc_overrange = 9,
    adc_underrange = 10,
    adc_overflow = 11,
    adc_underflow = 12,
    trigger_seq = 13,
    data_link_stat = 14,
    sharc_link_num = 15
    };
 
    struct dataitem_type_t
    {
 
    uint64_t res0 : 62;
 
    uint32_t itemtype : 2;
    };
 
    struct dataitem_data_t
    {
 
    uint32_t timestamp : 28;
 
    uint32_t res0 : 4;
 
    uint32_t adc : 16;
 
    uint32_t chi : 12;
    // uint32_t chi_adc : 4;
    // uint32_t chi_flag : 1;
    // uint32_t chi_module : 7;
 
    uint32_t veto : 1;
 
    uint32_t fail : 1;
 
    uint32_t itemtype : 2;
 
    uint32_t getChannelIdent_adc() const { return chi & 0xFUL; }
 
    uint32_t getChannelIdent_flag() const { return (chi >> 4) & 0x1UL; }
 
    uint32_t getChannelIdent_module() const { return (chi >> 5) & 0x7FUL; }
 
    inline void set(uint64_t timestamp_, uint32_t adc_, uint32_t chi_,
            bool veto_, bool fail_)
        {
        timestamp = timestamp_;
        res0 = 0;
        adc = adc_;
        chi = chi_;
        veto = veto_ ? 1 : 0;
        fail = fail_ ? 1 : 0;
        itemtype = static_cast<uint32_t>(itemtype_e::data);
        }
 
    void toCStringFull(char *s, uint32_t len) const
        {
        std::snprintf(s, len, "%2" PRIu32 " %09" PRIu32 " %02" PRIu32 " %05" PRIu32
                  " %02" PRIu32 " %01" PRIu32 " %03" PRIu32 " %01" PRIu32 " %01" PRIu32,
                  itemtype, timestamp, res0, adc,
                  getChannelIdent_adc(), getChannelIdent_flag(), getChannelIdent_module(),
                  veto, fail);
        }
    };
 
    struct dataitem_info_t
    {
 
    uint32_t timestamp : 28;
 
    uint32_t res0 : 4;
 
    uint32_t info : 20;
 
    uint32_t code : 4;
 
    uint32_t module : 6;
 
    uint32_t itemtype : 2;
 
    infocode_e getCode() const { return static_cast<infocode_e>(code); }
 
    uint32_t getChannelIdent() const
        {
        return (module << 5) + info;
        }
 
    inline void set(uint64_t timestamp_, uint32_t code_, uint32_t info_, uint32_t module_)
        {
        timestamp = timestamp_;
        res0 = 0;
        info = info_;
        code = code_;
        module = module_;
        itemtype = static_cast<uint32_t>(itemtype_e::info);
        }
 
    void toCStringFull(char *s, uint32_t len) const
        {
        std::snprintf(s, len, "%2" PRIu32 " %09" PRIu32 " %02" PRIu32 " %07" PRIu32 " %02" PRIu32 " %02" PRIu32,
                  itemtype, timestamp, res0, info, code, module);
        }
    };
 
    struct dataitem_tracehead_t
    {
 
    uint32_t timestamp : 28;
 
    uint32_t res0 : 4;
 
    uint32_t samplelength : 16;
 
    uint32_t chi : 12;
 
    uint32_t getChannelIdent_adc() const { return chi & 0xFUL; }
 
    uint32_t res1 : 2;
 
    uint32_t itemtype : 2;
 
    uint32_t getChannelIdent_flag() const { return (chi >> 4) & 0x1UL; }
 
    uint32_t getChannelIdent_module() const { return (chi >> 5) & 0x7FUL; }
 
    void toCStringFull(char *s, uint32_t len) const
        {
        std::snprintf(s, len, "%2" PRIu32 " %09" PRIu32 " %02" PRIu32 " %05" PRIu32
                  " %02" PRIu32 " %01" PRIu32 " %03" PRIu32 " %01" PRIu32,
                  itemtype, timestamp, res0, samplelength,
                  getChannelIdent_adc(), getChannelIdent_flag(), getChannelIdent_module(),
                  res1);
        }
    };
 
    struct dataitem_tracedata_t
    {
 
    uint16_t sample3 : 14;
    uint16_t res3 : 2;
 
    uint16_t sample2 : 14;
    uint16_t res2 : 2;
 
    uint16_t sample1 : 14;
    uint16_t res1 : 2;
 
    uint16_t sample0 : 14;
    uint16_t res0 : 2;
 
    inline void set(const uint16_t *samples)
        {
        sample0 = samples[0];
        sample1 = samples[1];
        sample2 = samples[2];
        sample3 = samples[3];
        }
 
    void toCStringFull(char *s, uint32_t len) const 
        {
        uint32_t rectype = static_cast<uint32_t>(itemtype_e::tracedata);
        std::snprintf(s, len, "%2" PRIu32 " %05" PRIu16 " %05" PRIu16 " %05" PRIu16 " %05" PRIu16,
                  rectype, sample0, sample1, sample2, sample3);
        }
    };
 
    union dataitem_t
    {
 
    dataitem_type_t type;
 
    dataitem_data_t data;
 
    dataitem_info_t info;
 
    dataitem_tracehead_t tracehead;
 
    dataitem_tracedata_t tracedata;
 
    uint64_t rawdata;
 
    inline static dataitem_t create(uint64_t v)
        {
        dataitem_t ret;
        ret.rawdata = v;
        return ret;
        }
 
    itemtype_e getType() const { return static_cast<itemtype_e>(type.itemtype); }
 
    inline dataitem_t asSwapped() const
        {
        return (dataitem_t::create(((rawdata & 0xFFFFFFFF) << 32ULL) | (rawdata >> 32ULL)));
        }
 
    inline void clear() { rawdata = 0; }
 
    void toCStringFull(char *s, uint32_t len) const
        {
        switch (getType())
        {
        case itemtype_e::tracedata:
            tracedata.toCStringFull(s, len);
            break;
        case itemtype_e::tracehead:
            tracehead.toCStringFull(s, len);
            break;
        case itemtype_e::info:
            info.toCStringFull(s, len);
            break;
        case itemtype_e::data:
            data.toCStringFull(s, len);
            break;
        }
        }
    };
 
 
    struct dataitem_ts_t {
    dataitem_t item;
    int64_t    ts;
    };
    
}