LogicalEventCollector.hpp

Go to the documentation of this file.

 
#ifndef H_POTTU_LOGICALEVENTCOLLECTOR
#define H_POTTU_LOGICALEVENTCOLLECTOR
 
 
#include "DetectorEvent.hpp"
 
#include <deque>
#include <cstdint>
#include <algorithm>
 
 
namespace pottu {
 
    
    template <class Sort, class Tr>
    class LogicalEventCollector {
    public:
 
    Sort &_sort;
    Tr   &_tr;
    
    // Trigger and event lengths. 
    int64_t _triggerDeadTime{300};
    int64_t _eventDelay{-100};
    int64_t _maxEventLength{600};
    
    struct event_collection_window_t {
        int64_t triggerTime;
        int64_t startTime;
        int64_t stopTime;
    };
    
    std::deque<event_collection_window_t>  _eventWindows;
 
    int64_t                                _tsLast{0};
    std::deque<pottu::DetectorEvent>       _queue;
 
    
    LogicalEventCollector( Sort &sort, Tr &tr,
                   int64_t triggerDeadTime,
                   int64_t eventDelay, int64_t maxEventLength )
        : _sort(sort),
          _tr(tr),
          _triggerDeadTime(triggerDeadTime),
          _eventDelay(eventDelay),
          _maxEventLength(maxEventLength)
        {
        }
 
 
    
 
    template <class Cont>
    void feed( const Cont &data ) noexcept {
    
        // Looping over all detector events
        for (auto &det : data)
        {
        // Timestamp
        // If the timestamp appears earlier than the last, empty all queues and settings
        // (no sense in considering those at this point.)
        const int64_t ts = det.time;
        if( ts < _tsLast ) {
            _queue.clear();
            _tsLast = 0;
            _eventWindows.clear();
            _tr.reset();
 
            _sort.onTimeOrderError();
        }
 
 
        const bool newTrigger = _tr.feed( det );
        const bool onDeadTime = _eventWindows.size() ? ts < _eventWindows.back().triggerTime + _triggerDeadTime
                                    : false;
 
        
        if( newTrigger && !onDeadTime ) {
            // Checking the end of the previous window and
            // shortening it if needed.
            if( _eventWindows.size() && _eventWindows.back().stopTime > ts+_eventDelay ) {
            _eventWindows.back().stopTime = ts+_eventDelay;
            //fmt::print( "## Adjusted the stop time\n" );
            }
        
            // Pushing new window to queue of windows. The end
            // of the window might be shortened when the next
            // trigger arrives.
            const event_collection_window_t window{ts, ts+_eventDelay, ts+_eventDelay+_maxEventLength };
            _eventWindows.push_back( window );
        }
        
        // Always pushing the event into the queue
        _queue.push_back( det );
        
        
        // Throwing away events we do not need 
        const int64_t ignoreUntil = _eventWindows.size()
            ? std::min(_eventWindows.front().startTime, ts+_eventDelay )
            : ts+_eventDelay;
        while( _queue.size() && _queue.front().time < ignoreUntil )
            _queue.pop_front();
        
        // Do we have data for event to populate it fully
        if( _eventWindows.size() && _eventWindows.front().stopTime < ts + _eventDelay ) {
            const auto iterLast = std::lower_bound( _queue.begin(), _queue.end(), _eventWindows.front().stopTime,
                                []( const pottu::DetectorEvent &e, const int64_t &value ){
                                return e.time < value; } );
        
            _sort.constructAndProcessLogicalEvent( _queue.begin(), iterLast,
                               _eventWindows.front().triggerTime,
                               _eventWindows.front().startTime, _eventWindows.front().stopTime );
        
            _queue.erase( _queue.begin(), iterLast );
            _eventWindows.pop_front();
        }
        
 
        // Needed to shield against time order error
        _tsLast = ts;
        }
 
    }
    
    };
 
}
 
 
#endif