TimeAdjuster.hpp

Go to the documentation of this file.

 
#ifndef H_TIMEADJUSTER
#define H_TIMEADJUSTER
 
#include "DetectorEvent.hpp"
#include "ContextBase.hpp"
#include "StageDetectorEventToDetectorEvent.hpp"
 
#include <array>
#include <deque>
#include <algorithm>
#include <stdexcept>
 
namespace pottu {
 
 
 
    class TimeAdjuster : public StageDetectorEventToDetectorEvent {
    public:
 
    TimeAdjuster()
        : _ctxh( ContextBase::getActive().createHandle("TimeAdjuster") )
        {
        _chTimeCorrections.fill(0);
        }
 
    void setCorrection( uint16_t ch, int64_t correction ) {
        if( ch > 4095 )
        throw std::runtime_error( "Ch number is bigger than 4095!" );
 
        _chTimeCorrections[ch] = correction;
        
        if( correction > _maxCorrection )
        _maxCorrection = correction;
        if( correction < _minCorrection )
        _minCorrection = correction;
        
        _correctionWidth = _maxCorrection-_minCorrection;
    }
 
    
    int64_t getCorrection( uint16_t ch ) const noexcept {
        return ch < 4095 ? _chTimeCorrections[ch] : 0; 
    }
 
    
 
    // TO BE REMOVED: template <class ContInput, class ContOutput>
    virtual void process( std::vector<DetectorEvent> &input, std::vector<DetectorEvent> &output ) {
        /* TO BE REMOVED:
        static_assert( std::is_same<typename ContInput::value_type,DetectorEvent>::value,
               "TimeAdjuster requires DetectorEvent as a input::value_type" );
        static_assert( std::is_same<typename ContOutput::value_type,DetectorEvent>::value,
               "TimeAdjuster requires DetectorEvent as a output::value_type" );
        */
        auto proci = _ctxh->processInstance();
 
        output.clear();
 
        // Adding time correction to each event
        for( auto &det : input ) {
 
        if( det.time < _tsPrev ) {
            _ctxh->logWarning( fmt::format( "TimeOrder error: {} -> {}, {} s.",
                            _tsPrev, det.time, (det.time-_tsPrev)*1e-8 ) );
            // Time order error! Clearing the queues
            while( _queue.size() ) {
            output.push_back( std::move( _queue.front() ) );
            _queue.pop_front();
            }
        }
        // Saving the time to see potential time order error later.
        _tsPrev = det.time;
 
        det.time += getCorrection( det.ch );
        
        while( _queue.size() && _queue.front().time + _correctionWidth < det.time ) {
            output.emplace_back( std::move( _queue.front() ) );
            _queue.pop_front();
        }
 
        const bool sortingNeeded = ( _queue.size() && _queue.back().time > det.time );
        _queue.emplace_back( std::move(det) );
        if( sortingNeeded )
            std::sort( _queue.begin(), _queue.end(), DetectorEvent::compTimeLess() );
 
        }
 
    }
    
    ContextHandle    *_ctxh;
    
    // Gives correction to be applied for a channel. 
    std::array<int64_t,4096> _chTimeCorrections;
 
    int64_t              _maxCorrection{0};
    int64_t              _minCorrection{0};
    int64_t              _correctionWidth{0};
 
    int64_t              _tsPrev{0};
 
    // Newest is last. These are in time order ALWAYS. However,
    // there might be a new event which will be put in between.
    std::deque<DetectorEvent> _queue;
    
    };
 
 
}
 
 
#endif