OfflineRevise.cxx

Go to the documentation of this file.

#include "RawDataCnv/OfflineRevise.h"
#include "RawDataCnv/SniperJSON.h"
#include <fstream>
#include <iostream>
 
OfflineRevise::OfflineRevise(const SniperJSON& json)
    : m_lastRun(-1),
      m_lastFlag(true)
{
    const 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;
        }
    }
}