DetectorEvent.hpp

Go to the documentation of this file.

 
#ifndef H_DETECTOREVENT
#define H_DETECTOREVENT
 
#include "dataitem.hpp"
 
 
#include <cstring>
#include <memory>
#include <vector>
 
 
namespace pottu {
 
    class DetectorEvent
    {
    public:
 
    using group_type = int16_t;
    using coord_type = int16_t;
 
    static DetectorEvent createInvalid() {
        return DetectorEvent();
    }
    
    struct compTimeLess {
        bool operator()( const DetectorEvent &det1, const DetectorEvent &det2 ) const noexcept {
        return det1.time < det2.time;
        }
    };
 
    struct compTimeGreater {
        bool operator()( const DetectorEvent &det1, const DetectorEvent &det2 ) const noexcept {
        return det1.time > det2.time;
        }
    };
 
    struct compCoordLess {
        bool operator()( const DetectorEvent &det1, const DetectorEvent &det2 ) const noexcept {
        return det1.coord < det2.coord;
        }
    };
 
    enum flags : uint16_t {
        FLAG_PILEUP     = 1 << 0,
        FLAG_OVERRANGE  = 1 << 1,
        FLAG_UNDERRANGE = 1 << 2,
        FLAG_OVERFLOW   = 1 << 3,
        FLAG_UNDERFLOW  = 1 << 4,
        FLAG_FAIL       = 1 << 5,
        FLAG_VETO       = 1 << 6,
        FLAG_INVALID    = 1 << 15
    };
 
    // /** \brief Clears all the members to zero. */
    //void clear() { std::memset( this, 0, sizeof(DetectorEvent) ); }
 
    void markPileup()    noexcept { flags |= FLAG_PILEUP; }
    void markOverrange() noexcept { flags |= FLAG_OVERRANGE; }
    void markUnderrange()noexcept { flags |= FLAG_UNDERRANGE; }
    void markOverflow()  noexcept { flags |= FLAG_OVERFLOW; }
    void markUnderflow() noexcept { flags |= FLAG_UNDERFLOW; }
    void markVeto()      noexcept { flags |= FLAG_VETO; }
    void markFail()      noexcept { flags |= FLAG_FAIL; }
    void markInvalid()   noexcept { flags |= FLAG_INVALID; }
 
    bool pileup()     const noexcept { return flags & FLAG_PILEUP; }
    bool overrange()  const noexcept { return flags & FLAG_OVERRANGE; }
    bool underrange() const noexcept { return flags & FLAG_UNDERRANGE; }
    bool overflow()   const noexcept { return flags & FLAG_OVERFLOW; }
    bool underflow()  const noexcept { return flags & FLAG_UNDERFLOW; }
    bool fail()       const noexcept { return flags & FLAG_FAIL; }
    bool veto()       const noexcept { return flags & FLAG_VETO; }
    bool good()       const noexcept { return flags == 0; }
 
    bool invalid()    const noexcept { return flags & FLAG_INVALID; }
 
    explicit operator bool() const { return !invalid(); }
 
    int64_t    time{0};
 
    uint16_t   ch{0};
    uint16_t   adc{0};
    uint16_t   flags{FLAG_INVALID};
 
    // Detector group index
    uint16_t   group{0};
 
    // Coordinate in detector group
    uint16_t   coord{0};
 
    // Calibrated energy
    float      e{0};
 
    
#if POTTU_ENABLE_TRACES
    std::vector<uint16_t> trace;
#endif
    
    };
 
    
 
    struct SelectorGroup {
    DetectorEvent::group_type group;
    
    bool operator()( const DetectorEvent &det ) const noexcept {
        return det.group == group;
    }
    };
 
    struct SelectorGroupAndCoord {
    DetectorEvent::group_type group;
    DetectorEvent::coord_type coord;
    
    bool operator()( const DetectorEvent &det ) const noexcept {
        return det.group == group && det.coord == coord;
    }
    };
 
 
    struct SelectorChannel {
    uint16_t ch;
    
    bool operator()( const DetectorEvent &det ) const noexcept {
        return det.ch == ch;
    }
    };
 
 
    struct SelectorGroupEnergy {
    DetectorEvent::group_type group;
    double                    eLow;
    double                    eHigh;
 
    bool operator()( const DetectorEvent &det ) const noexcept {
        return det.group == group && det.e >= eLow && det.e < eHigh;
    }
    };
 
    
    
    struct EventOpEnergy {
    double operator()( const DetectorEvent &det ) const noexcept {
        return det.e;
    }
    };
 
    
    struct EventOpADC {
    double operator()( const DetectorEvent &det ) const noexcept {
        return det.adc;
    }
    };
 
 
 
    
 
}
 
 
 
#endif