TimeStamper.hpp

Go to the documentation of this file.

 
#ifndef H_TIMESTAMPER
#define H_TIMESTAMPER
 
#include "dataitem.hpp"
#include "DetectorEvent.hpp"
#include "ContextBase.hpp"
#include "StageRawToStampedRaw.hpp"
 
#include <deque>
#include <vector>
#include <type_traits>
 
#include <iostream>
 
 
namespace pottu {
 
    class TimeStamper : public StageRawToStampedRaw {
    public:
 
    TimeStamper()
        : _ctxh( ContextBase::getActive().createHandle("TimeStamper") )
        {}
    
    //TO BE REMOVED: template <class ContInput, class ContOutput>
    void process( const std::vector<dataitem_t> &input, std::vector<dataitem_ts_t> &output ) {
        /* TO BE REMOVED:
        static_assert( std::is_same<typename ContInput::value_type,dataitem_t>::value,
               "TimeStamper requires dataitem_t as a input datapacket value_type" );
        static_assert( std::is_same<typename ContOutput::value_type,dataitem_ts_t>::value,
               "TimeStamper requires dataitem_ts_t as a output datapacket value_type" );
        */
        auto proci = _ctxh->processInstance();
        
        output.clear();
 
        for( const dataitem_t &di : input ) {
 
        if( di.getType() == itemtype_e::info
            && ( di.info.getCode() == infocode_e::sync100ts
             || di.info.getCode() == infocode_e::extendedts ) ) {
            
            // We have full time stamp!
            int64_t tsHigh = di.info.info;
            if( tsHigh == _tsHighPrev || tsHigh == _tsHighPrev+1 ) {
            
            if( _tsHighQueue-_tsHighPrev < 2 ) {
                // Not more than one lowts overflow occurred during the fill of the queue
 
                if( output.size() && _itemqueue.size() && output.back().ts > _itemqueue.front().ts ) {
                _ctxh->logError( "HAUKI" );
                }
                
                std::move( _itemqueue.begin(), _itemqueue.end(), std::back_inserter(output) );
                // Dont need to erase since the _itemqueue.clear() is soon called.
            } else {
                _ctxh->logWarning( "Timeorder error in low time bits." );
            }
            
            } else {
            _ctxh->logWarning( fmt::format( "Jump in high bits of timestamp: {} -> {}, dt = {} s.",
                              _tsHighPrev, tsHigh, (tsHigh-_tsHighPrev)*(1<<28ULL)*1e-8 ) );
            }
            // Always clear the queue.
            _itemqueue.clear();
            
            // Always push this event to the output directly
            int64_t ts = ( tsHigh << 28ULL | di.info.timestamp );
 
            output.push_back( {di, ts} );
 
            // Queue "starts" with this time stamp although
            // this item is not put there.
            _tsPrevIntoQueue = ts;
            _tsHighPrev = tsHigh;
            _tsHighQueue = tsHigh;
            
        } else if( di.getType() == itemtype_e::tracedata ) {
            
            // We dont have lowest time bits. Using time of
            // the previous one.
            _itemqueue.push_back( {di,_tsPrevIntoQueue} );
            
        } else {
            
            // We have lowest time bits. Using here "info" but
            // tracehead and data contains the timestamp in
            // same bits.
            int64_t ts = ( _tsHighQueue << 28ULL | di.info.timestamp );
            if( ts < _tsPrevIntoQueue ) {
            //_ctxh->logDebug( "lowts wrapped around" );
            ++_tsHighQueue;
            ts = ( _tsHighQueue << 28ULL | di.info.timestamp );
            }
            _itemqueue.push_back( {di,ts} );
            _tsPrevIntoQueue = ts;
            
        }
        
        
        }
 
    
    }
 
 
    private:
 
    ContextHandle             *_ctxh;
    
    std::deque<dataitem_ts_t>  _itemqueue;
    
    int64_t                    _tsHighPrev{0};
    int64_t                    _tsHighQueue{0};
    
    int64_t                    _tsPrevIntoQueue{0};
    
    };
 
 
}
 
 
#endif