dae_events.h

Go to the documentation of this file.

#ifndef DAE_EVENTS_H
#define DAE_EVENTS_H


struct DAEEventHeaderInfo
{
        unsigned header_type : 4;
        unsigned header_length : 5;
        unsigned unused1 : 2;
        unsigned bad_frame : 1;
        unsigned unused2 : 1;
        unsigned fifo_read_late : 1;
        unsigned memory_wrap : 1;
        unsigned frame_overflow : 1;
        unsigned fifo_overflows : 16;
};


struct DAEEventHeaderVetos // 32bits
{
        unsigned fifo : 1;
        unsigned smp : 1;
        unsigned unused4 : 2;
        unsigned ts2_pulse : 1;
        unsigned wrong_pulse : 1;
        unsigned isis_slow : 1;
        unsigned unused3 : 5;
        unsigned external : 4;
        unsigned unused2 : 8;
        unsigned fast_chopper : 4;
        unsigned unused1 : 4;
};


enum DAEEventHeaderMarker { DummyEndOfRunMarker=0xcfffffff, DummyHeaderMarker=0xdfffffff, EndOfRunMarker=0xefffffff, AllValuesFilledInMarker=0xffffffff };

static const int DAEEventHeaderFixedMarker = 0xffffffff;  

struct DAEEventHeader
{
        uint32_t marker0; 
        uint32_t marker1; 
        DAEEventHeaderInfo info;
        uint32_t frame_number;
        struct DAETime
        {
            uint32_t low;
                uint32_t high;
        } time;
        struct
        {
                unsigned period : 23;
                unsigned unused1 : 9;
        };
        uint32_t num_events;
        struct
        {
            unsigned protons : 10;
            unsigned unused : 22;
        };
        DAEEventHeaderVetos vetos;
};

inline std::ostream& operator<<(std::ostream& os, const DAEEventHeader::DAETime& t)
{
        os << (((uint64_t)t.high) << 32) + t.low;
        return os;
}

// POSLUT spectrum number and time channels from card. Should not see time_channel=0, first time_channel=1
struct DetectorEvent32
{
        unsigned time_channel : 16;
        unsigned spectrum : 16;
};


// for 32MHz timing, time is after frame sync in 31.25 ns steps
struct DetectorEvent64
{
        unsigned position : 12;
        unsigned dim : 4;
        unsigned unused1 : 16;
        unsigned time : 31;
        unsigned unused2 : 1;
};

namespace dae_events_conditions {
    BOOST_STATIC_ASSERT(sizeof(DAEEventHeaderInfo) == 4);
        BOOST_STATIC_ASSERT(sizeof(DAEEventHeaderVetos) == 4);
    BOOST_STATIC_ASSERT(sizeof(DAEEventHeader) == 40);    
    BOOST_STATIC_ASSERT( (sizeof(DAEEventHeader) % 8) == 0 );   // Must always be an even number of 32bit words (i.e. a multiple of 8 bytes) - see above 
    BOOST_STATIC_ASSERT(sizeof(DetectorEvent32) == 4);
    BOOST_STATIC_ASSERT(sizeof(DetectorEvent64) == 8);
}

static const unsigned DAE_EVENT_HEADER_WORDS = (sizeof(DAEEventHeader) / 4);

class DAEEventList
{
private:
        static uint32_t checkEventsFrame(const isisU32_t* buffer, uint32_t maxlen, DAEstatus& status);
        static uint32_t getCompleteFramesLen(const isisU32_t* buffer, uint32_t len, DAEstatus& status);
        static void getEventHeaderErrorMessage(const DAEEventHeader* head, unsigned code, std::string& error_message);
        static int checkEventHeaderImpl(const DAEEventHeader* head);
public:
        static void checkEventHeader(const DAEEventHeader* head);
        static int checkEventHeader(const DAEEventHeader* head, std::string& error_message);
        static void checkEvents(const isisU32_t* buffer, uint32_t maxlen, DAEstatus& status);
        static bool isEndRunHeader(const DAEEventHeader* head, DAEstatus& status);
        static int findValidEventHeaderOffset(const isisU32_t* buffer, uint32_t len, DAEstatus& status);
        static void printEventHeader(const DAEEventHeader* head, std::ostream& os);
        static void printDetectorEvents(const DetectorEvent32* events, int n, std::ostream& os);
        static void DAETimeToSystemTime(const DAEEventHeader::DAETime& daetime, SYSTEMTIME& systime);
        static void SystemTimeToDAETime(const SYSTEMTIME& systime, DAEEventHeader::DAETime& daetime);
        static void DAETimeToFILETIME(const DAEEventHeader::DAETime& daetime, FILETIME& filetime);
        template<typename T> static void DAETimeToOffset(const DAEEventHeader::DAETime& daetime, time_t base, T& offset);
        static void OffsetToDAETime(time_t base, double offset, DAEEventHeader::DAETime& daetime);
        static void FILETIMEToDAETime(const FILETIME& filetime, DAEEventHeader::DAETime& daetime);
        static std::string DAETimeAsString(const DAEEventHeader::DAETime& daetime);
};

#endif /* DAE_EVENTS_H */