RawHistogrammer.hpp

Go to the documentation of this file.

 
#ifndef H_POTTU_RAWHISTOGRAMMER
#define H_POTTU_RAWHISTOGRAMMER
 
 
 
#include "result_collection_support.hpp"
 
#include "DetectorEvent.hpp"
#include "ContextBase.hpp"
#include "DAQChannels.hpp"
#include "StageDetectorEvent.hpp"
 
#include <vector>
 
 
namespace pottu {
 
    template <class EventOp = EventOpEnergy>
    class RawHistogrammer : public StageDetectorEvent {
    public:
 
    RawHistogrammer( EventOp eventOp )
        : _ctxh( ContextBase::getActive().createHandle("RawHistogrammer") ),
          _eventOp(eventOp),
          _histos(4096)
        {}
 
    void setHistogram( uint16_t ch, _histogram_1d_type *h ) {
        _histos[ch] = h;
    }
 
    _histogram_1d_type *getHistogram( uint16_t ch ) noexcept {
        if( ch >= 4096 )
        return nullptr;
        return _histos[ch];
    }
 
    void createAndSetHistogramsChannelInterval( _result_tree_type tree, const std::string &prefix,
                            uint16_t chFirst, uint16_t chLast,
                            double low, double high, unsigned int binc ) {
        for( uint16_t ch = chFirst; ch < chLast; ++ch ) {
        std::string name = fmt::format( "{}{:04d}", prefix, ch );
        auto h1 = createHistogram1D( tree, name.c_str(), low, high, binc );
        setHistogram( ch, h1 );
        }
    }
    
    template <class DAQCH> 
    void setGroup( DetectorEvent::group_type group, double low, double high, unsigned int binc,
               const DAQCH &daqchannels, _result_tree_type tree ) {
 
        auto &g = daqchannels.getGroup( group );
 
        std::string hname = fmt::format("Raw histogram of group {}", g.getName() );
        //auto h1 = tree->createHistogram1D( hname, low, high, binc );
        auto h1 = createHistogram1D( tree, hname.c_str(), low, high, binc );
        
        const auto &chs = g.getChannels();
        for( const auto &ch : chs )
        setHistogram( ch, h1 );
        
        _ctxh->logInfo( fmt::format( "Assigned {} channels to raw group histogram for group \'{}\'.",
                     chs.size(), g.getName() ) );
    }
    
    //template <class Cont>
    virtual void process( std::vector<DetectorEvent> &data ) noexcept {
        /*
        static_assert( std::is_same<typename Cont::value_type,DetectorEvent>::value,
               "RawHistogrammer requires DetectorEvent as a datapacket value_type" );
        */
        auto proci = _ctxh->processInstance();
        
        for( const auto &event : data ) {
        if( _histos[event.ch] ) {
            fill( _histos[event.ch], _eventOp(event) );
        }
        }
    }
 
 
    ContextHandle                                  *_ctxh;
 
    EventOp                                         _eventOp;
    std::vector<_histogram_1d_type *>               _histos;
    };
 
 
 
}
 
 
#endif