DetectorEventGenerator.hpp

Go to the documentation of this file.

 
#ifndef H_POTTU_DETECTOREVENTGENERATOR
#define H_POTTU_DETECTOREVENTGENERATOR
 
 
#include "result_collection_support.hpp"
 
#include "dataitem.hpp"
#include "DetectorEvent.hpp"
#include "StageStampedRawToDetectorEvent.hpp"
 
#include <fmt/base.h>
 
#include <deque>
#include <vector>
#include <algorithm>
 
 
 
namespace pottu {
 
    
    class DetectorEventGenerator : public StageStampedRawToDetectorEvent {
    public:
    DetectorEventGenerator( _result_tree_type results )
        : _ctxh( ContextBase::getActive().createHandle("DetectorEventGenerator") )
        {
        auto branch = createSubTree( results, "detector_event_generator" ); 
        _h_rectypes  = createHistogram1DPow2( branch, "rectypes", 2, 2 );
        _h_infocodes = createHistogram1DPow2( branch, "infocodes", 4, 4 );
    
        _h_ch_data       = createHistogram1DPow2( branch, "ch_data", 12, 12 );
        // Data which is ignored due to timeorder errors or data before fulltime
        _h_ch_dataIgnored = createHistogram1DPow2( branch, "ch_dataIgnored", 12, 12 );
        _h_ch_trace      = createHistogram1DPow2( branch, "ch_trace", 12, 12 );
 
        _h_ch_pileup     = createHistogram1DPow2( branch, "ch_pileup", 12, 12 );
        _h_ch_overrange  = createHistogram1DPow2( branch, "ch_overrange", 12, 12 );
        _h_ch_underrange = createHistogram1DPow2( branch, "ch_underrange", 12, 12 );
        _h_ch_overflow   = createHistogram1DPow2( branch, "ch_overflow", 12, 12 );
        _h_ch_underflow  = createHistogram1DPow2( branch, "ch_underflow", 12, 12 );
 
        _h_ch_pileup_marked = createHistogram1DPow2( branch, "ch_pileup_marked", 12, 12 );
        _h_ch_overrange_marked  = createHistogram1DPow2( branch, "ch_overrange_marked", 12, 12 );
        _h_ch_underrange_marked = createHistogram1DPow2( branch, "ch_underrange_marked", 12, 12 );
        _h_ch_overflow_marked   = createHistogram1DPow2( branch, "ch_overflow_marked", 12, 12 );
        _h_ch_underflow_marked  = createHistogram1DPow2( branch, "ch_underflow_marked", 12, 12 );
 
        _h_ch_fail   = createHistogram1DPow2( branch, "ch_fail", 12, 12 );
        _h_ch_veto   = createHistogram1DPow2( branch, "ch_veto", 12, 12 );
 
        _h_ch_adcbit14  = createHistogram1DPow2( branch, "ch_adcbit14", 12, 12 );
        _h_ch_adcbit15  = createHistogram1DPow2( branch, "ch_adcbit15", 12, 12 );
        }
    
 
    //TO BE REMOVED: template <class ContInput, class ContOutput>
    void process( const std::vector<dataitem_ts_t> &input, std::vector<DetectorEvent> &output ) {
        /* TO BE REMOVED:
        static_assert( std::is_same<typename ContInput::value_type,dataitem_ts_t>::value,
               "DetectorEventGenerator requires dataitem_ts_t as a input::value_type" );
        static_assert( std::is_same<typename ContOutput::value_type,DetectorEvent>::value,
               "DetectorEventGenerator requires DetectorEvent as a output::value_type" );
        */
        auto proci = _ctxh->processInstance();
 
        output.clear();
        size_t counter{0};
 
#if POTTU_ENABLE_TRACES==1   
        std::vector<uint16_t> traceData;
        uint16_t              traceCh{0};
        int64_t               traceTime{0};
        std::size_t           tracePos{0} ;
#endif
        
        for( const dataitem_ts_t &di : input ) {
        //_h_rectypes->fillNoRangeTesting( di.item.type.itemtype );
        fillInteger( _h_rectypes, di.item.type.itemtype );
        
        if( di.ts < _tsPrev ) {
            _ctxh->logWarning( fmt::format( "TimeOrder error: {} -> {}, {} s.\n  input.size()={}, output.size()={}, counter={}",
                            _tsPrev, di.ts, (di.ts-_tsPrev)*1e-8 ,
                            input.size(), output.size(), counter ) );
 
            ++_timeOrderErrorCounter;
            // Moving all the events out (no any
            // pileup... markings over the timestamp error
            // boundary)
            std::move( _itemqueue.begin(), _itemqueue.end(), std::back_inserter(output) );
            _itemqueue.clear();
        }
 
        
        switch( di.item.getType() ) {
        case itemtype_e::tracedata:
            // Actual tracedata
#if POTTU_ENABLE_TRACES==1
            if( tracePos + 4 <= traceData.size() ) {
            traceData[ tracePos++ ] = di.item.tracedata.sample0;
            traceData[ tracePos++ ] = di.item.tracedata.sample1;
            traceData[ tracePos++ ] = di.item.tracedata.sample2;
            traceData[ tracePos++ ] = di.item.tracedata.sample3;            
            }
            if( tracePos>0 && tracePos == traceData.size() ) {
            // Trace is now collected. Checking if it can be assigned to the previous detector event
            if( _itemqueue.size() && _itemqueue.back().ch == traceCh && _itemqueue.back().time == traceTime ) {
                _itemqueue.back().trace = std::move( traceData );
                //fmt::print( "Trace found and assigned for {}\n", traceCh );
                tracePos = 0;
            } else {
                fmt::print( "No dataitem found for trace {}\n", traceCh );
            }
            tracePos = 0;
            traceCh = 0;
            }
#endif
            break;
        case itemtype_e::tracehead:
        {
            // New trace is starting here
#if POTTU_ENABLE_TRACES==1
            traceData.resize( di.item.tracehead.samplelength, 0 );
            traceCh = di.item.tracehead.chi;
            traceTime = di.ts;
            tracePos = 0;
#endif
            
            fillInteger( _h_ch_trace, di.item.tracehead.chi );
            break;
        }
        case itemtype_e::info:
        {
            //_h_infocodes->fillNoRangeTesting( di.item.info.code );
            fillInteger( _h_infocodes, di.item.info.code );
            
            switch( di.item.info.getCode() ) {
            case infocode_e::pileup: {
            const auto ch = di.item.info.getChannelIdent();
            //_h_ch_pileup->fill( ch );
            fillInteger( _h_ch_pileup, ch );
 
            // Trying to find the actual data event
            for( auto rit = _itemqueue.rbegin(); rit != _itemqueue.rend(); ++rit ) {
                const auto tdiff = di.ts - rit->time;
                if( tdiff > _pileupSearchtime )
                break;
                if( rit->ch == ch ) {
                rit->markPileup();
                fillInteger( _h_ch_pileup_marked, ch );
                break;
                }
            }
 
            break;
            }
            case infocode_e::adc_overrange:
            {
            const auto ch = di.item.info.getChannelIdent();
            fillInteger( _h_ch_overrange, ch );
 
            // Trying to find the actual data event
            for( auto rit = _itemqueue.rbegin(); rit != _itemqueue.rend(); ++rit ) {
                const auto tdiff = di.ts - rit->time;
                if( tdiff > _overrangeSearchtime )
                break;
                if( rit->ch == ch ) {
                rit->markOverrange();
                fillInteger( _h_ch_overrange_marked, ch );
                break;
                }
            }
                
            break;
            }
            case infocode_e::adc_underrange:
            {
            const auto ch = di.item.info.getChannelIdent();
            fillInteger( _h_ch_underrange, ch );
 
            // Trying to find the actual data event
            for( auto rit = _itemqueue.rbegin(); rit != _itemqueue.rend(); ++rit ) {
                const auto tdiff = di.ts - rit->time;
                if( tdiff > _underrangeSearchtime )
                break;
                if( rit->ch == ch ) {
                rit->markUnderrange();
                fillInteger( _h_ch_underrange_marked, ch );
                break;
                }
            }
                
            break;
            }
            case infocode_e::adc_overflow:
            {
            const auto ch = di.item.info.getChannelIdent();
            fillInteger( _h_ch_overflow, ch );
 
            // Trying to find the actual data event
            for( auto rit = _itemqueue.rbegin(); rit != _itemqueue.rend(); ++rit ) {
                const auto tdiff = di.ts - rit->time;
                if( tdiff > _overflowSearchtime )
                break;
                if( rit->ch == ch ) {
                rit->markOverflow();
                fillInteger( _h_ch_overflow_marked, ch );
                break;
                }
            }
                
            break;
            }
            case infocode_e::adc_underflow:
            {
            const auto ch = di.item.info.getChannelIdent();
            fillInteger( _h_ch_underflow, ch );
 
            // Trying to find the actual data event
            for( auto rit = _itemqueue.rbegin(); rit != _itemqueue.rend(); ++rit ) {
                const auto tdiff = di.ts - rit->time;
                if( tdiff > _underflowSearchtime )
                break;
                if( rit->ch == ch ) {
                rit->markUnderflow();
                fillInteger( _h_ch_underflow_marked, ch );
                break;
                }
            }
                
            break;
            }
            default:
            break;
            }
            
            break;
        }
 
        case itemtype_e::data:
        {
            fillInteger( _h_ch_data, di.item.data.chi );
            if( di.item.data.veto )
            fillInteger( _h_ch_veto, di.item.data.chi );
            if( di.item.data.fail )
            fillInteger( _h_ch_fail, di.item.data.chi );
            if( di.item.data.adc >> 14 & 0x1 )
            fillInteger( _h_ch_adcbit14, di.item.data.chi );
            if( di.item.data.adc >> 15 & 0x1 )
            fillInteger( _h_ch_adcbit15, di.item.data.chi );
            
            // Putting data always to the queue.
            DetectorEvent det;
            det.time  = di.ts;
            det.ch    = di.item.data.chi;
            det.adc   = di.item.data.adc;
            det.flags = 0;
            det.group = 0;
            det.e     = 0;
 
#if POTTU_ENABLE_TRACES
            if( traceData.size() && traceCh==det.ch && traceTime==det.time ) {
            // Trace assigned to a data event
            det.trace = std::move( traceData );
            fmt::print( "Trace found and assigned for {}\n", det.ch );
            tracePos = 0;
            }
#endif
            
            _itemqueue.push_back( std::move(det) );
            break;
        }
        }
 
        _tsPrev = di.ts;
        ++counter;
        }
 
        if( _itemqueue.size() ) {
        const int64_t lastTSForPop = _itemqueue.back().time - _queue_minlength;
        
        auto it_last  = std::upper_bound( _itemqueue.begin(), _itemqueue.end(), lastTSForPop,
                          [](const int64_t &value, const DetectorEvent &e ){
                              return value < e.time; } );
        std::move( _itemqueue.begin(), it_last, std::back_inserter(output) );
        _itemqueue.erase( _itemqueue.begin(), it_last );
        }
        
        
    }
        
 
    
    ContextHandle             *_ctxh;
 
 
    int64_t                    _queue_minlength{10000};
    int64_t                    _pileupSearchtime{1000};
    int64_t                    _underrangeSearchtime{1000};
    int64_t                    _overrangeSearchtime{1000};
    int64_t                    _underflowSearchtime{1000};
    int64_t                    _overflowSearchtime{1000};
    
    int64_t                    _tsPrev{0};
    std::deque<DetectorEvent>  _itemqueue;
 
    // Number of timeorder errors in full time stamps.
    uint64_t                   _timeOrderErrorCounter{0};
 
    // Histograms
    _histogram_1d_pow2_type  *_h_rectypes;
    _histogram_1d_pow2_type  *_h_infocodes;
 
    _histogram_1d_pow2_type  *_h_ch_data;
    _histogram_1d_pow2_type  *_h_ch_dataIgnored;
    _histogram_1d_pow2_type  *_h_ch_trace;
 
    _histogram_1d_pow2_type  *_h_ch_pileup;
    _histogram_1d_pow2_type  *_h_ch_overrange;
    _histogram_1d_pow2_type  *_h_ch_underrange;
    _histogram_1d_pow2_type  *_h_ch_overflow;
    _histogram_1d_pow2_type  *_h_ch_underflow;
 
        _histogram_1d_pow2_type  *_h_ch_pileup_marked;
    _histogram_1d_pow2_type  *_h_ch_overrange_marked;
    _histogram_1d_pow2_type  *_h_ch_underrange_marked;
    _histogram_1d_pow2_type  *_h_ch_overflow_marked;
    _histogram_1d_pow2_type  *_h_ch_underflow_marked;
 
    _histogram_1d_pow2_type  *_h_ch_fail;
    _histogram_1d_pow2_type  *_h_ch_veto;
 
    _histogram_1d_pow2_type  *_h_ch_adcbit14;
    _histogram_1d_pow2_type  *_h_ch_adcbit15;
    };
    
    
};
 
 
 
#endif