In This Package:

LtbTime.cc

Go to the documentation of this file.

/*
 *  LtbTime.cc
 *  LtbReadoutFormat
 *
 *  Created by Simon Patton on 7/21/10.
 *  Copyright 2010 DayaBay Collaboration. All rights reserved.
 *
 */
#include "LtbReadoutFormat/LtbTime.h"

#include <ctime>

#include "DaqReadoutFormat/ByteBuffer.h"
#include "LtbReadoutFormat/LtbTraits.h"

using DybDaq::ByteBuffer;
using DybDaq::LtbTime;
using DybDaq::LtbTraits;

#define TIME_T_BUILTIN_TYPE unsigned long

static const unsigned int kYearZero = 1970;
static const unsigned int kTmBaseYear = 1900;

LtbTime::LtbTime(const time_t& dateTime,
                 const unsigned int halfNanoseconds,
                 const unsigned int accumulation,
                 const LtbTraits& traits) :
LtbBuffer(new char[traits.timeSize() * kBytesInInt],
          traits) {
    traits.initializeTime(buffer());
    setDateTime(dateTime);
    setHalfNanoseconds(halfNanoseconds);
    setAccumulation(accumulation);
}

LtbTime::LtbTime(const LtbTraits::LtbDateTime& dateTime,
                 const unsigned int halfNanoseconds,
                 const unsigned int accumulation,
                 const LtbTraits& traits) :
LtbBuffer(new char[traits.timeSize() * kBytesInInt],
          traits) {
    traits.initializeTime(buffer());
    setDateTime(dateTime);
    setHalfNanoseconds(halfNanoseconds);
    setAccumulation(accumulation);
}

LtbTime::LtbTime(const DybDaq::ByteBuffer& byteBuffer,
                 const LtbTraits& traits) :
LtbBuffer(byteBuffer,
          traits) {
}

LtbTime::~LtbTime() {
}

unsigned int LtbTime::formatComponent() const {
    return LtbTraits::kUnixTime;
}

unsigned int LtbTime::year() const {
    if (4 > ltbTraits().majorVersion()) {
        unsigned int result = readUnsignedInt(LtbTraits::kYear);
        if (0 == result) {
            return kYearZero;
        }
        return result;
    }
    const time_t time = unixTime();
    struct tm* tmStruct = gmtime(&time);
    return tmStruct->tm_year + kTmBaseYear;
}

unsigned int LtbTime::month() const {
    if (4 > ltbTraits().majorVersion()) {
        return readUnsignedInt(LtbTraits::kMonth);
    }
    const time_t time = unixTime();
    struct tm* tmStruct = gmtime(&time);
    return tmStruct->tm_mon + 1;
}

unsigned int LtbTime::day() const {
    if (4 > ltbTraits().majorVersion()) {
        return readUnsignedInt(LtbTraits::kDay);
    }
    const time_t time = unixTime();
    struct tm* tmStruct = gmtime(&time);
    return tmStruct->tm_mday;
}

unsigned int LtbTime::hour() const {
    if (4 > ltbTraits().majorVersion()) {
        return readUnsignedInt(LtbTraits::kHour);
    }
    const time_t time = unixTime();
    struct tm* tmStruct = gmtime(&time);
    return tmStruct->tm_hour;
}

unsigned int LtbTime::minutes() const {
    if (4 > ltbTraits().majorVersion()) {
        return readUnsignedInt(LtbTraits::kMinutes);
    }
    const time_t time = unixTime();
    struct tm* tmStruct = gmtime(&time);
    return tmStruct->tm_min;
}

unsigned int LtbTime::seconds() const {
    if (4 > ltbTraits().majorVersion()) {
        return readUnsignedInt(LtbTraits::kSeconds);
    }
    const time_t time = unixTime();
    struct tm* tmStruct = gmtime(&time);
    return tmStruct->tm_sec;
}

unsigned int LtbTime::ticks() const {
    if (4 > ltbTraits().majorVersion()) {
        return readUnsignedInt(LtbTraits::kTicks);
    }
    return (halfNanoseconds() / 25U);
}

time_t LtbTime::unixTime() const {
    if (4 > ltbTraits().majorVersion()) {
        struct tm gmtAsLocal;
        gmtAsLocal.tm_sec = seconds();
        gmtAsLocal.tm_min = minutes();
        gmtAsLocal.tm_hour = hour();
        gmtAsLocal.tm_mday = day();
        gmtAsLocal.tm_mon = month() - 1;
        gmtAsLocal.tm_year = year() - kTmBaseYear;
        const time_t local = mktime(&gmtAsLocal);
        struct tm lcl = *localtime(&local);
        struct tm gmt = *gmtime(&local);
        gmt.tm_isdst = gmtAsLocal.tm_isdst;
        const time_t a = mktime(&lcl);
        const time_t b = mktime(&gmt);
        return local + (a - b);
    }
    const unsigned int highUnixTime = readUnsignedInt(LtbTraits::kHighUnixTime);
    const unsigned int lowUnixTime = readUnsignedInt(LtbTraits::kLowUnixTime);
    const TIME_T_BUILTIN_TYPE unixTime = (highUnixTime << 16U) | lowUnixTime;
    return *((const time_t*)(&unixTime));
}

unsigned int LtbTime::halfNanoseconds() const {
    if (4 > ltbTraits().majorVersion()) {
        return ticks() * 25U;
    }
    const unsigned int highNonaseconds = readUnsignedInt(LtbTraits::kHighNanoseconds);
    const unsigned int lowNanoseconds = readUnsignedInt(LtbTraits::kLowNanoseconds);
    return (highNonaseconds << 4U) | lowNanoseconds;
}

int LtbTime::accumulation() const {
    if (4 > ltbTraits().majorVersion()) {
        return 0;
    }
    const unsigned int highAccumulation = readUnsignedInt(LtbTraits::kHighAccumulation);
    const unsigned int lowAccumulation = readUnsignedInt(LtbTraits::kLowAccumulation);
    return (highAccumulation << 4U) + lowAccumulation;
}

unsigned int LtbTime::bufferSize() const {
    return ltbTraits().timeSize();
}

void LtbTime::setDateTime(const LtbTraits::LtbDateTime& dateTime) {
    if (4 > ltbTraits().majorVersion()) {
        writeField(dateTime.year(),
                   LtbTraits::kYear);
        writeField(dateTime.month(),
                   LtbTraits::kMonth);
        writeField(dateTime.day(),
                   LtbTraits::kDay);
        writeField(dateTime.hour(),
                   LtbTraits::kHour);
        writeField(dateTime.minutes(),
                   LtbTraits::kMinutes);
        writeField(dateTime.seconds(),
                   LtbTraits::kSeconds);
        return;
    }
    const time_t timeToCopy = dateTime.unixTime();
    const TIME_T_BUILTIN_TYPE time = *((TIME_T_BUILTIN_TYPE*)(&timeToCopy));
    writeField((((unsigned int)time) >> 16U) & 0x0000ffffU,
               LtbTraits::kHighUnixTime);
    writeField(((unsigned int)time) & 0x0000ffffU,
               LtbTraits::kLowUnixTime);
    
}

void LtbTime::setDateTime(const time_t& dateTime) {
    if (4 > ltbTraits().majorVersion()) {
        const tm* time = gmtime(&dateTime);
        writeField(time->tm_year + kTmBaseYear,
                   LtbTraits::kYear);
        writeField(time->tm_mon + 1,
                   LtbTraits::kMonth);
        writeField(time->tm_mday,
                   LtbTraits::kDay);
        writeField(time->tm_hour,
                   LtbTraits::kHour);
        writeField(time->tm_min,
                   LtbTraits::kMinutes);
        writeField(time->tm_sec,
                   LtbTraits::kSeconds);
        return;
    }
    const TIME_T_BUILTIN_TYPE time = *((TIME_T_BUILTIN_TYPE*)(&dateTime));
    writeField((((unsigned int)time) >> 16U) & 0x0000ffffU,
               LtbTraits::kHighUnixTime);
    writeField(((unsigned int)time) & 0x0000ffffU,
               LtbTraits::kLowUnixTime);
    
}

void LtbTime::setHalfNanoseconds(const unsigned int halfNanoseconds) {
    if (4 > ltbTraits().majorVersion()) {
        writeField(halfNanoseconds / 25U,
                   LtbTraits::kTicks);
        return;
    }
    writeField((halfNanoseconds >> 4U) & 0x0fffffffU,
               LtbTraits::kHighNanoseconds);
    writeField(halfNanoseconds & 0x0000000fU,
               LtbTraits::kLowNanoseconds);
}

void LtbTime::setAccumulation(const int accumulation) {
    if (4 > ltbTraits().majorVersion()) {
        return;
    }
    writeField((accumulation >> 4U) & 0x0fffffffU,
               LtbTraits::kHighAccumulation);
    writeField(accumulation & 0x0000000fU,
               LtbTraits::kLowAccumulation);
}

---