TCPEventStreamDefs.h

Go to the documentation of this file.

#ifndef TCP_EVENT_STREAM_DEFS_H
#define TCP_EVENT_STREAM_DEFS_H


struct TCPStreamEventHeader
{
        uint32_t marker1;   
        uint32_t marker2;   
        uint32_t version;   
        uint32_t length;    
        uint32_t type;      

        enum StreamDataType { InvalidStream=0, Setup=1, Neutron=2, SE=3 };  
        static const uint32_t marker = 0xffffffff;  
        TCPStreamEventHeader() : marker1(marker), marker2(marker), version(current_version), length(sizeof(TCPStreamEventHeader)), type(InvalidStream) { }
        TCPStreamEventHeader(uint32_t type_) : marker1(marker), marker2(marker), version(current_version), length(sizeof(TCPStreamEventHeader)), type(type_) { }
        bool isValid() const { return marker1 == marker && marker2 == marker && length >= sizeof(TCPStreamEventHeader) && majorVersion() == TCPStreamEventHeader::major_version && minorVersion() >= TCPStreamEventHeader::minor_version && type != InvalidStream; }
        static const uint32_t major_version = 1; 
        static const uint32_t minor_version = 0; 
        static const uint32_t current_version = (major_version << 16) | minor_version; 
        uint32_t majorVersion() const { return version >> 16; }
        uint32_t minorVersion() const { return version & 0xffff; }
};

struct TCPStreamEventHeaderSetup
{
        enum { StartTime=0x1, RunNumber=0x2, RunState=0x4, InstName=0x8 } ChangedFields;
        uint32_t length;    
        time_t start_time; 
        int run_number;  
        int run_state;     
    char inst_name[32];   

        TCPStreamEventHeaderSetup() : start_time(0), run_number(0), run_state(0), length(sizeof(TCPStreamEventHeaderSetup)) { inst_name[0] = '\0'; }
        bool isValid() const { return length >= sizeof(TCPStreamEventHeaderSetup); }
        uint32_t changedFields(const TCPStreamEventHeaderSetup& ref) const
        {
                uint32_t changed = 0;
                changed |= ( start_time != ref.start_time ?  StartTime : 0 );
                changed |= ( run_number != ref.run_number ?  RunNumber : 0 );
                changed |= ( run_state != ref.run_state ?  RunState : 0 );
                changed |= ( strcmp(inst_name, ref.inst_name) ?  InstName : 0 );
            return changed;
        } 
};

struct TCPStreamEventHeaderSE
{
    float time_offset;
};

struct TCPStreamEventHeaderNeutron
{
        uint32_t length;    
        uint32_t frame_number;   
        uint32_t period;   
        float protons;  
        float frame_time_zero;  
        uint32_t nevents;               

        TCPStreamEventHeaderNeutron() : nevents(0), length(sizeof(TCPStreamEventHeaderNeutron)) { }
        bool isValid() const { return length >= sizeof(TCPStreamEventHeaderNeutron); }
};

struct TCPStreamEventNeutron
{
        float time_of_flight;  
        uint32_t spectrum;   
};

struct TCPStreamEventDataNeutron
{
        TCPStreamEventHeader head; 
        TCPStreamEventHeaderNeutron     head_n; 
        std::vector<TCPStreamEventNeutron> data; 

        TCPStreamEventDataNeutron() : head(TCPStreamEventHeader::Neutron) { }
        TCPStreamEventDataNeutron(const TCPStreamEventHeader& head_) : head(head_) { }
        bool isValid() const { return head.isValid() && head_n.isValid() && (head.type == TCPStreamEventHeader::Neutron) && (data.size() == head_n.nevents); }
};

struct TCPStreamEventDataSetup
{
        TCPStreamEventHeader head; 
        TCPStreamEventHeaderSetup       head_setup;
        TCPStreamEventDataSetup() : head(TCPStreamEventHeader::Setup) { }
        TCPStreamEventDataSetup(const TCPStreamEventHeader& head_) : head(head_) { }
        bool isValid() const { return head.isValid() && head_setup.isValid() && (head.type == TCPStreamEventHeader::Setup); }
};

// placeholder fro SE data
struct TCPStreamEventDataSE
{
        TCPStreamEventHeader head; 
        TCPStreamEventHeaderSE  head_s;
};

#endif /* TCP_EVENT_STREAM_DEFS_H */