DAQChannels.hpp

Go to the documentation of this file.

 
#ifndef H_DAQCHANNELS
#define H_DAQCHANNELS
 
#include "DetectorEvent.hpp"
#include "ContextBase.hpp"
#include "StageDetectorEvent.hpp"
#include "result_collection_support.hpp"
 
#include <vector>
#include <string>
#include <stdexcept>
#include <map>
#include <algorithm>
 
 
 
namespace pottu {
 
    class DAQChannels : public StageDetectorEvent {
    public:
 
 
    struct channel_info_t {
        DetectorEvent::group_type group{0};
        DetectorEvent::coord_type coord{0}; 
        std::string               name;
    };
 
    
    class DetectorGroup {
    public:
 
        void add( uint16_t ch ) {
        _channels.push_back(ch);
        std::sort( _channels.begin(), _channels.end() );
        }
 
        void remove( uint16_t ch ) {
        auto it = std::find( _channels.begin(), _channels.end(), ch );
        if( it != _channels.end() )
            _channels.erase( it );
        }
 
        const std::string &getName() const noexcept { return _name; }
 
        const std::vector<uint16_t> &getChannels() const noexcept { return _channels; }
 
    private:
        friend class DAQChannels;
        
        std::string               _name;
        // \brief Vector of channels which belongs to this group
        std::vector<uint16_t>     _channels;
    };
 
    
    DAQChannels() 
        : _ctxh( ContextBase::getActive().createHandle("DAQChannels") ),
          _chInfos(4096) {}
 
    
    void addGroup( DetectorEvent::group_type group, const std::string &name ) {
        throwIfNotValidName( name );
        if( group < 1 )
        throw std::runtime_error( "DAQChannels::addGroup(): group must be >= 1!" );
        if( _groups.find( group ) != _groups.end() )
        throw std::runtime_error( "DAQChannels::addGroup(): group exists already" );
        DetectorGroup g;
        g._name = name;
        _groups[ group ] = std::move(g);
    }
 
    
    void setChannel( uint16_t channel, DetectorEvent::group_type group,
             DetectorEvent::coord_type coord, const std::string &name ) {
        throwIfNotValidName(name);
        // Erases channel from earlier group if assigned
        if( _chInfos[channel].group != 0 )
        _groups[_chInfos[channel].group].remove( channel );
 
        auto it = _groups.find( group );
        if( it == _groups.end() )
        throw std::runtime_error( fmt::format( "DAQChannels::setChannel(): group {} doesnt exist", group ) );
        it->second.add( channel );
        _chInfos[channel] = channel_info_t{ group, coord, name };
    }
 
 
    uint16_t getCh( const std::string &name ) const {
        for( uint16_t ch = 0; ch < _chInfos.size(); ++ch ) {
        if( _chInfos[ch].name == name )
            return ch;
        }
        throw std::runtime_error( "Channel with given name not found" );
    }
 
 
    uint16_t getCh( DetectorEvent::group_type group, DetectorEvent::coord_type coord ) const {
        for( uint16_t ch = 0; ch < _chInfos.size(); ++ch ) {
        if( _chInfos[ch].group == group &&
            _chInfos[ch].coord == coord )
            return ch;
        }
        throw std::runtime_error( "Channel with given group and coord not found" );
    }
 
    
    const std::map<DetectorEvent::group_type, DetectorGroup> &getGroups() const noexcept {
        return _groups;
    }
    
    
    const DetectorGroup &getGroup( DetectorEvent::group_type group ) const {
        auto it = _groups.find( group );
        if( it == _groups.end() )
        throw std::runtime_error( fmt::format( "DAQChannels::getChannel(): group {} doesnt exist", group ) );
        return it->second;
    }
 
    
    const std::vector<channel_info_t> &getChInfos() const noexcept { return _chInfos; }
 
    
    virtual void process( std::vector<DetectorEvent> &data ) noexcept {
        auto proci = _ctxh->processInstance();
 
        for( auto &event : data ) {
        event.group = _chInfos[event.ch].group;
        event.coord = _chInfos[event.ch].coord;
        }
    }
 
    private:
    ContextHandle                                     *_ctxh;
    
    std::vector<channel_info_t>                        _chInfos;
    std::map<DetectorEvent::group_type, DetectorGroup> _groups;
    };
 
 
 
}
 
 
#endif