OfflineRevise.cxx

Go to the documentation of this file.

#include <string>
#include <vector>
#include <map>
#include <sstream>
#include <typeinfo>
#include <exception>
 
class SniperJSON
{
public:
    typedef std::vector<SniperJSON>::const_iterator vec_iterator;
    typedef std::map<std::string, SniperJSON>::const_iterator map_iterator;
 
    // default constructor
    SniperJSON();
 
    // construct from a json string
    SniperJSON(const std::string &jstr);
 
    // whether this is a scalar or string
    bool isScalar() const { return m_type > 2; }
 
    // whether this is a vector
    bool isVector() const { return m_type == 2; }
 
    // whether this is a map
    bool isMap() const { return m_type == 1; }
 
    /* get a C++ object from this element, T can be
     * type[1]: C++ scalar and std::string
     * type[2]: std::vector< type[1,2,3] >
     * type[3]: std::map< type[1], type[1,2,3] >
     */
    template <typename T>
    T get() const;
 
    // push_back an element in case of a vector
    bool push_back(const SniperJSON &var);
 
    // insert a key/value pair in case of a map
    bool insert(const std::string &key, const SniperJSON &val);
 
    // clear all the contents of this element
    void reset();
 
    // get the array/vector or object/map size
    int size() const;
 
    // get the vector begin iterator
    vec_iterator vec_begin() const { return m_jvec.begin(); }
    // get the vector end iterator
    vec_iterator vec_end() const { return m_jvec.end(); }
 
    // get the object in vector via index
    SniperJSON &operator[](int index) { return m_jvec.at(index); }
    // get the object in vector via index
    const SniperJSON &operator[](int index) const { return m_jvec.at(index); }
 
    // get the map begin iterator
    map_iterator map_begin() const { return m_jmap.begin(); }
    // get the map end iterator
    map_iterator map_end() const { return m_jmap.end(); }
    // find the iterator via key
    map_iterator find(const std::string &key) const { return m_jmap.find(key); }
 
    // get the object in map via key
    SniperJSON &operator[](const std::string &key);
    // get the object in map via key
    const SniperJSON &operator[](const std::string &key) const;
 
    // load json from an input stream
    static SniperJSON load(std::istream &is);
 
    // load json from a string
    static SniperJSON loads(const std::string &jstr);
 
private:
    typedef std::string::size_type StrCursor;
 
    // 0:invalid, 1:object/map, 2:array/vector, 3:string, 9:other scalars
    int m_type;
    // scalar or std::string element holder
    std::string m_jvar;
    // array/vector element holder
    std::vector<SniperJSON> m_jvec;
    // object/map element holder
    std::map<std::string, SniperJSON> m_jmap;
 
    // control string for space charactors
    static const std::string SPACES;
    // control string for delimit charactors
    static const std::string DELIMITS;
 
    // construct a sub-element from a json string
    SniperJSON(const std::string &jstr, StrCursor &cursor);
 
    // initialize the json element from a string
    void init(const std::string &jstr, StrCursor &cursor);
 
    // get next valid charactor
    char getValidChar(const std::string &jstr, StrCursor &cursor);
 
    // read the content of a json object/map to m_jmap;
    void readObjectMap(const std::string &jstr, StrCursor &cursor);
 
    // read the content of a json array/vector to m_jvec
    void readArrayVec(const std::string &jstr, StrCursor &cursor);
 
    // read the content of a json string to m_jvar
    void readStringStr(const std::string &jstr, StrCursor &cursor);
 
    // read the content of other scalars to m_jvar
    void readScalarStr(const std::string &jstr, StrCursor &cursor);
 
    // function template helps to access type[1]
    template <typename T>
    inline void toCppVar(T &var) const;
 
    // function template helps to access type[2]
    template <typename T>
    inline void toCppVar(std::vector<T> &var) const;
 
    // function template helps to access type[3]
    template <typename K, typename V>
    inline void toCppVar(std::map<K, V> &var) const;
 
    // an inner class for any exception while json parsing
    class Exception : public std::exception
    {
    public:
        Exception(const std::string &msg);
        Exception(const std::string &jstr, int cursor);
        virtual ~Exception() throw();
        const char *what() const throw();
 
    private:
        std::string m_msg;
    };
};
 
template <typename T>
T SniperJSON::get() const
{
    T v;
    toCppVar(v);
    return v;
}
 
template <typename T>
inline void SniperJSON::toCppVar(T &var) const
{
    if (m_type == 9)
    {
        std::stringstream ss;
        ss << m_jvar;
        ss >> var;
 
        if (ss.eof())
        {
            return;
        }
    }
 
    throw Exception(
        std::string("cannot set <") + typeid(T).name() + "> with '" + m_jvar + "'");
}
 
template <>
inline void SniperJSON::toCppVar<bool>(bool &var) const
{
    if (m_type == 9)
    {
        if (m_jvar == "true")
        {
            var = true;
            return;
        }
        else if (m_jvar == "false")
        {
            var = false;
            return;
        }
    }
 
    throw Exception(std::string("cannot set <bool> with '") + m_jvar + "'");
}
 
template <>
inline void SniperJSON::toCppVar<std::string>(std::string &var) const
{
    if (m_type == 3)
    {
        var = m_jvar.substr(1, m_jvar.size() - 2);
        return;
    }
 
    throw Exception(std::string("cannot set <std::string> with '") + m_jvar + "'");
}
 
template <typename T>
inline void SniperJSON::toCppVar(std::vector<T> &var) const
{
    if (m_type == 2)
    {
        for (vec_iterator it = m_jvec.begin(); it != m_jvec.end(); ++it)
        {
            var.push_back(it->get<T>());
        }
        return;
    }
 
    throw Exception(std::string("not a valid vector"));
}
 
//This implementaiton should be replaced by "std::is_same" when c++11 is valid 
namespace PreCXX11 {
    struct true_value {
        static bool value;
    };
    bool true_value::value = true;
 
    struct false_value {
        static bool value;
    };
    bool false_value::value = false;
 
    template<typename, typename>
        struct is_same : public false_value {};
 
    template<typename T>
        struct is_same<T, T> : public true_value {};
}
 
template <typename K, typename V>
inline void SniperJSON::toCppVar(std::map<K, V> &var) const
{
    if (m_type == 1)
    {
        for (map_iterator it = m_jmap.begin(); it != m_jmap.end(); ++it)
        {
            var.insert(std::make_pair(
                SniperJSON(
                    PreCXX11::is_same<K, std::string>::value ? it->first : it->first.substr(1, it->first.size() - 2))
                    .get<K>(),
                it->second.get<V>()));
        }
        return;
    }
 
    throw Exception(std::string("not a valid map"));
}
 
const std::string SniperJSON::SPACES(" \n\t\r");
const std::string SniperJSON::DELIMITS(", \n]}\t\r");
 
SniperJSON::SniperJSON()
    : m_type(0)
{
}
 
SniperJSON::SniperJSON(const std::string &jstr)
    : m_type(0)
{
    StrCursor cursor = 0;
    init(jstr, cursor);
 
    cursor = jstr.find_first_not_of(SniperJSON::SPACES, cursor);
    if (cursor != std::string::npos)
    {
        throw Exception(jstr, cursor);
    }
}
 
SniperJSON::SniperJSON(const std::string &jstr, StrCursor &cursor)
    : m_type(0)
{
    init(jstr, cursor);
}
 
bool SniperJSON::push_back(const SniperJSON &var)
{
    if (m_type == 2 || m_type == 0)
    {
        m_jvec.push_back(var);
        m_type = 2;
        return true;
    }
    return false;
}
 
bool SniperJSON::insert(const std::string &key, const SniperJSON &val)
{
    if (m_type == 1 || m_type == 0)
    {
        std::string _key = '"' + key + '"';
        m_jmap.insert(std::make_pair(_key, val));
        m_type = 1;
        return true;
    }
    return false;
}
 
void SniperJSON::reset()
{
    m_type = 0;
    m_jvar.clear();
    m_jvec.clear();
    m_jmap.clear();
}
 
int SniperJSON::size() const
{
    if (m_type == 1)
    {
        return m_jmap.size();
    }
    else if (m_type == 2)
    {
        return m_jvec.size();
    }
 
    return -1;
}
 
SniperJSON &SniperJSON::operator[](const std::string &key)
{
    return m_jmap.at('"' + key + '"');
}
 
const SniperJSON &SniperJSON::operator[](const std::string &key) const
{
    return m_jmap.at('"' + key + '"');
}
 
SniperJSON SniperJSON::load(std::istream &is)
{
    std::ostringstream oss;
    oss << is.rdbuf();
 
    return loads(oss.str());
}
 
SniperJSON SniperJSON::loads(const std::string &jstr)
{
    return SniperJSON(jstr);
}
 
void SniperJSON::init(const std::string &jstr, StrCursor &cursor)
{
    switch (getValidChar(jstr, cursor))
    {
    case '{': //object
        readObjectMap(jstr, cursor);
        m_type = 1;
        break;
    case '[': //array
        readArrayVec(jstr, cursor);
        m_type = 2;
        break;
    case '"': //string
        readStringStr(jstr, cursor);
        m_type = 3;
        break;
    default: //number, true, false or null
        readScalarStr(jstr, cursor);
        m_type = 9;
    }
}
 
char SniperJSON::getValidChar(const std::string &jstr, StrCursor &cursor)
{
    cursor = jstr.find_first_not_of(SPACES, cursor);
    if (cursor != std::string::npos)
    {
        return jstr.at(cursor);
    }
    throw Exception(jstr, cursor);
}
 
void SniperJSON::readObjectMap(const std::string &jstr, StrCursor &cursor)
{
    bool status = true;
 
    if (getValidChar(jstr, ++cursor) != '}')
    {
        --cursor; //reset the cursor just before the first key
        do
        {
            readStringStr(jstr, ++cursor);
            const std::string &key = m_jvar;
            if (key.size() == 2 || getValidChar(jstr, cursor) != ':')
            {
                status = false;
                break;
            }
            m_jmap.insert(std::make_pair(key, SniperJSON(jstr, ++cursor)));
        } while (getValidChar(jstr, cursor) == ',');
    }
 
    m_jvar.clear();
 
    if (status && getValidChar(jstr, cursor) == '}')
    {
        ++cursor;
        return;
    }
 
    throw Exception(jstr, cursor);
}
 
void SniperJSON::readArrayVec(const std::string &jstr, StrCursor &cursor)
{
    if (getValidChar(jstr, ++cursor) != ']')
    {
        --cursor; //reset the cursor just before the first variable
        do
        {
            m_jvec.push_back(SniperJSON(jstr, ++cursor));
        } while (getValidChar(jstr, cursor) == ',');
    }
 
    if (getValidChar(jstr, cursor) == ']')
    {
        ++cursor;
        return;
    }
 
    throw Exception(jstr, cursor);
}
 
void SniperJSON::readStringStr(const std::string &jstr, StrCursor &cursor)
{
    if (getValidChar(jstr, cursor) == '"')
    {
        StrCursor pstart = cursor;
        cursor = jstr.find('"', pstart + 1);
        if (cursor != std::string::npos)
        {
            ++cursor;
            m_jvar = jstr.substr(pstart, cursor - pstart);
            return;
        }
    }
 
    throw Exception(jstr, cursor);
}
 
void SniperJSON::readScalarStr(const std::string &jstr, StrCursor &cursor)
{
    StrCursor pstart = cursor;
    cursor = jstr.find_first_of(DELIMITS, pstart + 1);
    if (cursor != std::string::npos || pstart == 0)
    {
        m_jvar = jstr.substr(pstart, cursor - pstart);
        return;
    }
 
    throw Exception(jstr, cursor);
}
 
SniperJSON::Exception::Exception(const std::string &msg)
    : m_msg("json error: ")
{
    m_msg += msg;
}
 
SniperJSON::Exception::Exception(const std::string &jstr, int cursor)
    : m_msg("invalid json:\n")
{
    m_msg += jstr.substr(0, cursor + 1);
    m_msg += " <<< parsing error";
}
 
SniperJSON::Exception::~Exception() throw()
{
}
 
const char *SniperJSON::Exception::what() const throw()
{
    return m_msg.c_str();
}
 
#include "RawDataCnv/OfflineRevise.h"
#include <fstream>
#include <iostream>
 
OfflineRevise::OfflineRevise(const std::string& conf)
    : m_lastRun(-1),
      m_lastFlag(true)
{
    std::ifstream f(conf.c_str());
    SniperJSON json = SniperJSON::load(f);
 
    {
        SniperJSON& c1 = json["Ets1MissingSecond"];
        for (SniperJSON::vec_iterator it = c1["RunRanges"].vec_begin();
                it != c1["RunRanges"].vec_end();
                ++it)
        {
            m_runRanges.push_back(std::make_pair(
                        (*it)["From"].get<int>(),
                        (*it)["To"].get<int>() ));
        }
 
        m_runs = c1["Runs"].get<std::vector<int> >();
 
        //for ( std::vector<std::pair<int, int> >::iterator it = m_runRanges.begin();
        //        it != m_runRanges.end(); ++it) {
        //    std::cout << "RunRange: " << it->first << ", " << it->second << std::endl;
        //}
        //for (std::vector<int>::iterator it = m_runs.begin();
        //        it != m_runs.end(); ++it) {
        //    std::cout << "Run: " << *it << std::endl;
        //}
 
        m_tRoundSwitch = json["TimeRoundSwitch"].get<int>();
    }
}
 
OfflineRevise::~OfflineRevise()
{
}
 
void OfflineRevise::fixHeader(Event::EventHeader* header)
{
    bool goodFlag = true;
    int run = header->runNumber();
 
    if ( run == m_lastRun ) {
        goodFlag = m_lastFlag;
    }
    else {
        for ( std::vector<std::pair<int, int> >::iterator it = m_runRanges.begin();
                it != m_runRanges.end();
                ++it)
        {
            if ( run >= it->first && run <= it->second ) {
                goodFlag = false;
                break;
            }
        }
 
        if ( goodFlag && std::find(m_runs.begin(), m_runs.end(), run) != m_runs.end() ) {
            goodFlag = false;
        }
 
        m_lastFlag = goodFlag;
        m_lastRun = run;
        m_lastEvent = header->eventNumber();
        m_t0Sec = header->time();
        m_t0NanoShift0 = -1;
        m_t0NanoShift1 = -1;
        m_lastEts1 = 0;
        m_lastEts2Old = 0;
        m_lastEts2New = 0;
    }
 
    if ( ! goodFlag ) {
        fixEts1(header);
        fixEts2(header);
    }
}
 
void OfflineRevise::fixEts1(Event::EventHeader* header)
{
    long tNow = header->time() - m_t0Sec;
    unsigned long _ets1 = header->etsT1();
    long ets1NanoSec = _ets1 % 2000000;
 
    if ( tNow == 0 ) {
        long _shift0 = ets1NanoSec % 2000000;
        if ( _shift0 > m_t0NanoShift0 ) {
            m_t0NanoShift0 = _shift0;
        }
    }
    else if ( tNow == 1 ) {
        if ( m_t0NanoShift1 == -1 ) {
            if ( ets1NanoSec > m_t0NanoShift0 ) {
                m_t0NanoShift1 = ets1NanoSec;
                //std::cout << "Shift " << m_t0NanoShift0 << "  " << m_t0NanoShift1 << std::endl;
            }
        }
    }
 
    if ( m_t0NanoShift1 > 0 && ets1NanoSec >= m_t0NanoShift1 ) {
        --tNow;
    }
 
    unsigned long ets1 = tNow*2000000 + ets1NanoSec;
 
    int evtDiff = header->eventNumber() - m_lastEvent;
 
    if ( labs(ets1-m_lastEts1) < 1000000 && abs(evtDiff) < 100 ) {
        //m_lastEts1 = ets1;
    }
    else {
        if ( ets1NanoSec > m_t0NanoShift0-200000 ) {
            long tDiff = ets1NanoSec - m_lastEts1%2000000;
            if ( tDiff > 1000000 ) {
                if ( evtDiff < 100 ) {
                    tNow = m_lastEts1/2000000 - 1;
                }
            }
            else if ( tDiff < -1000000 ) {
                if ( evtDiff > 100 ) {
                    tNow = m_lastEts1/2000000 + 1;
                }
            }
            else {
                tNow = m_lastEts1/2000000;
            }
            ets1 = tNow*2000000 + ets1NanoSec;
        }
    }
 
    header->setEtsT1(ets1);
    m_lastEvent = header->eventNumber();
    if ( abs(evtDiff) < 100 ) {
        m_lastEts1  = ets1;
    }
}
 
void OfflineRevise::fixEts2(Event::EventHeader* header)
{
    unsigned long _ets2 = header->etsT2();
 
    if ( _ets2 != 0 ) {
        if ( _ets2 == m_lastEts2Old ) {
            header->setEtsT2(m_lastEts2New);
        }
        else {
            unsigned long ets1 = header->etsT1();
            long ets1NanoSec = ets1%2000000;
            long tNow = ets1/2000000;
 
            long ets2NanoSec = _ets2 % 2000000;
 
            long tDiff = ets2NanoSec - ets1NanoSec;
            if ( tDiff > 1000000 ) {
                --tNow;
            }
            else if ( tDiff < -1000000 ) {
                ++tNow;
            }
 
            unsigned long ets2 = tNow*2000000 + ets2NanoSec;
 
            header->setEtsT2(ets2);
            m_lastEts2Old = _ets2;
            m_lastEts2New = ets2;
        }
    }
}