dae_events.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "isisvme.h"
#include "dae_events.h"

void DAEEventList::checkEvents(const isisU32_t* buffer, uint32_t len, DAEstatus& status)
{
        unsigned len_done = 0, len_bit = 1;
        while(len > 0 && len_bit > 0)
        {
                len_bit = checkEventsFrame(buffer, len, status);
                buffer += len_bit;
                len -= len_bit;
                len_done += len_bit;
        }
        if (len != 0)
        {
                throw std::exception("incomplete frame in buffer");
        }
}

void DAEEventList::checkEventHeader(const DAEEventHeader* head)
{
        int code = checkEventHeaderImpl(head);
        if (code != 0)
        {
                std::string error_message;
                getEventHeaderErrorMessage(head, code, error_message);
                throw std::runtime_error(error_message);
        }
}

int DAEEventList::checkEventHeader(const DAEEventHeader* head, std::string& error_message)
{
        int code = checkEventHeaderImpl(head);
        if (code != 0)
        {
                getEventHeaderErrorMessage(head, code, error_message);
        }
        return code;
}

int DAEEventList::checkEventHeaderImpl(const DAEEventHeader* head)
{
        int ret = 0x0;
        if (head->marker0 != DAEEventHeaderFixedMarker)
        {
                ret += 0x1;
        }
        if ( (head->marker1 != EndOfRunMarker) && (head->marker1 != AllValuesFilledInMarker) )
        {
                if ( (head->marker1 == DummyHeaderMarker) || (head->marker1 == DummyEndOfRunMarker) )
                {
                        ret += 0x20;
                }
                else
                {
                        ret += 0x2;
                }
        }
        if ( (head->marker1 == EndOfRunMarker) && (head->num_events != 0) )
        {
                ret += 0x4;
        }
        if ( head->info.header_length != DAE_EVENT_HEADER_WORDS )
        {
                ret += 0x8;
        }
        if ( head->info.header_length % 2 != 0 )
        {
                ret += 0x10;
        }
        return ret;
}

void DAEEventList::getEventHeaderErrorMessage(const DAEEventHeader* head, unsigned code, std::string& error_message)
{
        std::ostringstream oss;
        if (code & 0x1)
        {
                oss << "marker0=0x" << std::hex << head->marker0 << std::dec << ". ";
        }
        if (code & 0x2)
        {
                oss << "marker1=0x" << std::hex << head->marker1 << std::dec << ". ";
        }
        if (code & 0x4)
        {
                oss << "end run header: num_events=" << head->num_events << " (!= 0). ";
        }
        if (code & 0x8)
        {
                oss << "header_length field: " << head->info.header_length << " != " << DAE_EVENT_HEADER_WORDS << ". ";
        }
        if (code & 0x10)
        {
                oss << "header size: " << head->info.header_length << " is not an even number of 32bit words. ";
        }
        if (code & 0x20)
        {
                oss << "marker1=0x" << std::hex << head->marker1 << std::dec << " (Dummy). ";
        }
        error_message = oss.str();
}




int DAEEventList::findValidEventHeaderOffset(const isisU32_t* buffer, uint32_t len, DAEstatus& status)
{
        std::string error_message;
        if (len < DAE_EVENT_HEADER_WORDS)   // need to check here as subtracting unsigned values could cause a problem in for loop  
        {
                return -1;
        }
        for(int i=0; i < (len - DAE_EVENT_HEADER_WORDS); ++i)
        {
                if (buffer[i] == DAEEventHeaderFixedMarker)
                {
                        if (checkEventHeader(reinterpret_cast<const DAEEventHeader*>(buffer+i), error_message) == 0)
                        {
                                return i;
                        }
                }
        }
        return -1;
}

uint32_t DAEEventList::getCompleteFramesLen(const isisU32_t* buffer, uint32_t len, DAEstatus& status)
{
        unsigned n = 0;
        while( (len - n) > DAE_EVENT_HEADER_WORDS )
        {
                const DAEEventHeader* head = reinterpret_cast<const DAEEventHeader*>(buffer + n);
                checkEventHeader(head);
                unsigned frame_len = DAE_EVENT_HEADER_WORDS + head->num_events;   
                if (n + frame_len > len)
                {
                        break;
                }
                n += frame_len;
        }
        return n;
}

uint32_t DAEEventList::checkEventsFrame(const isisU32_t* buffer, uint32_t len, DAEstatus& status)
{
        if (len < DAE_EVENT_HEADER_WORDS)
        {
                throw std::exception("short frame - no header");
        }
        const DAEEventHeader* head = reinterpret_cast<const DAEEventHeader*>(buffer);
        checkEventHeader(head);
        int n = head->num_events;
        int frame_len = head->info.header_length + n;
        if ( frame_len > len )
        {
                throw std::exception("short frame - not enough events");
        }
//      DetectorEvent32* ev = reinterpret_cast<DetectorEvent32*>(buffer + head->info.header_length);
//      for(int i=0; i<n; ++i)
//      {
//              ev[i].spectrum;
//              ev[i].time_channel;
//      }
        return frame_len;
}

bool DAEEventList::isEndRunHeader(const DAEEventHeader* head, DAEstatus& /*status*/)
{
        checkEventHeader(head);
        if (head->marker1 == EndOfRunMarker)
        {
                return true;
        }
        else
        {
                return false;
        }
}

void DAEEventList::DAETimeToSystemTime(const DAEEventHeader::DAETime& daetime, SYSTEMTIME& systime)
{
        FILETIME filetime;
        DAETimeToFILETIME(daetime, filetime);
        if (FileTimeToSystemTime(&filetime, &systime) == 0)
        {
                memset(&systime, 0, sizeof(systime));   // error in FileTimeToSystemTime
        }
}

void DAEEventList::SystemTimeToDAETime(const SYSTEMTIME& systime, DAEEventHeader::DAETime& daetime)
{
        FILETIME filetime;
        if (SystemTimeToFileTime(&systime, &filetime) != 0)
        {
                FILETIMEToDAETime(filetime, daetime);
        }
        else
        {
                memset(&daetime, 0, sizeof(daetime));   // error in SystemTimeToFileTime
        }
}

void DAEEventList::DAETimeToFILETIME(const DAEEventHeader::DAETime& daetime, FILETIME& filetime)
{
        ULARGE_INTEGER ularge;
        ularge.LowPart = daetime.low;
        ularge.HighPart = daetime.high;
        ularge.QuadPart /= 5;   // convert from 20ns to 100ns units
        filetime.dwLowDateTime = ularge.LowPart;
        filetime.dwHighDateTime = ularge.HighPart;
}

template <typename T>
void DAEEventList::DAETimeToOffset(const DAEEventHeader::DAETime& daetime, time_t base, T& offset)
{
        SYSTEMTIME systime;
        DAETimeToSystemTime(daetime, systime);
        Poco::Timestamp base_timestamp = Poco::Timestamp::fromEpochTime(base);
        Poco::DateTime dae_dt(systime.wYear, systime.wMonth, systime.wDay, systime.wHour, systime.wMinute, systime.wSecond, systime.wMilliseconds); 
        offset = static_cast<T>(dae_dt.timestamp() - base_timestamp) / static_cast<T>(1000000);    // Poco::Timestamp::TimeDiff is in microseconds 
}

template void DAEEventList::DAETimeToOffset(const DAEEventHeader::DAETime& daetime, time_t base, float& offset);
//template void DAEEventList::DAETimeToOffset(const DAEEventHeader::DAETime& daetime, time_t base, double& offset);

void DAEEventList::OffsetToDAETime(time_t base, double offset, DAEEventHeader::DAETime& daetime)
{
        Poco::Timestamp base_timestamp = Poco::Timestamp::fromEpochTime(base);
        base_timestamp += static_cast<int64_t>(offset * 1.0e6); // Poco::Timestamp::TimeDiff is in microseconds
        Poco::DateTime dae_dt(base_timestamp);
        SYSTEMTIME systime;
        systime.wYear = static_cast<WORD>(dae_dt.year());
        systime.wMonth = static_cast<WORD>(dae_dt.month());
        systime.wDay = static_cast<WORD>(dae_dt.day());
        systime.wHour = static_cast<WORD>(dae_dt.hour());
        systime.wMinute = static_cast<WORD>(dae_dt.minute());
        systime.wSecond = static_cast<WORD>(dae_dt.second());
        systime.wMilliseconds = static_cast<WORD>(dae_dt.millisecond());
        SystemTimeToDAETime(systime, daetime);
}


void DAEEventList::FILETIMEToDAETime(const FILETIME& filetime, DAEEventHeader::DAETime& daetime)
{
        ULARGE_INTEGER ularge;
        ularge.LowPart = filetime.dwLowDateTime;
        ularge.HighPart = filetime.dwHighDateTime;
        ularge.QuadPart *= 5;   // convert from 100ns to 20ns units
        daetime.low = ularge.LowPart;
        daetime.high = ularge.HighPart;
}

std::string DAEEventList::DAETimeAsString(const DAEEventHeader::DAETime& daetime)
{
        std::string s1, s2;
        SYSTEMTIME systime;   // SYSTEMTIME is in UTC
        DAETimeToSystemTime(daetime, systime);
        Poco::format(s1, "%04u-%02u-%02u", 
                static_cast<unsigned>(systime.wYear), static_cast<unsigned>(systime.wMonth), static_cast<unsigned>(systime.wDay)); 
        Poco::format(s2, "%sT%02u:%02u:%02u.%u", s1, static_cast<unsigned>(systime.wHour), 
                static_cast<unsigned>(systime.wMinute), static_cast<unsigned>(systime.wSecond), 
                static_cast<unsigned>(systime.wMilliseconds));   // all the casts seem to be required - just using "%uh" didn't work
        return s2;
}

void DAEEventList::printEventHeader(const DAEEventHeader* head, std::ostream& os)
{
        std::string err_str;
        if (checkEventHeader(head, err_str) != 0)
        {
                os << "Frame header invalid: " << err_str << "\n";
        }
        os << "Frame " << head->frame_number << "\n";
        os << "Num events " << head->num_events << "\n";
        os << "Time " << DAETimeAsString(head->time) << "\n";
}

void DAEEventList::printDetectorEvents(const DetectorEvent32* events, int n, std::ostream& os)
{
        for(int i=0; i<n; ++i)
        {
                os << "time channel " << events[i].time_channel << " spectrum " << events[i].spectrum << std::endl;
        }
}