jyfl_nucspec_detectors.hpp

Go to the documentation of this file.

 
#ifndef H_POTTU_JYFL_NUCSPEC_DETECTORS
#define H_POTTU_JYFL_NUCSPEC_DETECTORS
 
 
#include "DetectorEvent.hpp"
 
 
#include <cstdint>
#include <limits>
 
 
namespace pottu {
 
    namespace jyfl_nucspec_std_detectors_2023_03 {
 
    
    extern const uint8_t fpBegeRing[3];
    extern const float fpBegeTheta[3];
    extern const float fpBegePhi[3];
 
    extern const uint8_t fpCloverRing[4];
    extern const float fpCloverTheta[3];
    extern const float fpCloverPhi[3];
 
    
    extern const uint32_t jytubeRing[92];
 
    
    extern const uint8_t jg1Ph1Ring[45];
    extern const float jg1Ph1Theta[45];
    extern const float jg1Ph1Phi[45];
 
    extern const uint8_t jgPh1Ring[15];
    extern const float jgPh1Theta[15];
    extern const float jgPh1Phi[15];
      
    extern const uint8_t jgCloverRing[96];
    extern const float jgCloverTheta[96];
    extern const float jgCloverPhi[96];  
 
    
 
 
    struct TACSInfo {
        pottu::DetectorEvent detTof;
        void clear() noexcept {
        detTof.markInvalid();
        };
    };
 
 
    
 
    class DSSDInfo
    {
    public:
        // Position of highest x energy seen
        int16_t x{-1};
        // Position of highest y energy seen
        int16_t y{-1};
        // Highest x energy
        float xe{0};
        // Highest y energy
        float ye{0};
 
        pottu::DetectorEvent detX;
        pottu::DetectorEvent detY;
    
        // Multiplicities
        uint8_t xmulti{0};
        uint8_t ymulti{0};
    
        std::vector<pottu::DetectorEvent> strips;
    
        void clear() noexcept {
        x=-1;
        y=-1;
        xe=0;
        ye=0;
        xmulti=0;
        ymulti=0;
        strips.clear();
        detX.markInvalid();
        detY.markInvalid();
        }
    };
 
 
    struct MWPCInfo {
        pottu::DetectorEvent  detX;
        pottu::DetectorEvent  detY;
        pottu::DetectorEvent  detLogic;
 
        void clear() noexcept {
        detX.markInvalid();
        detY.markInvalid();
        detLogic.markInvalid();
        }
    };
 
 
    struct GreatMWPCInfo {
        pottu::DetectorEvent  detX1;
        pottu::DetectorEvent  detX2;
        pottu::DetectorEvent  detY1;
        pottu::DetectorEvent  detY2;
        pottu::DetectorEvent  detDE;
 
        void clear() noexcept {
        detX1.markInvalid();
        detX2.markInvalid();
        detY1.markInvalid();
        detY2.markInvalid();
        detDE.markInvalid();
        }
    };
 
    
    struct MWPCInfo_V2305 {
        pottu::DetectorEvent  detX1;
        pottu::DetectorEvent  detX2;
        pottu::DetectorEvent  detY;
        pottu::DetectorEvent  detLogic;
 
        // Position in mm in x direction
        float x{ std::numeric_limits<float>::quiet_NaN() };  
        // Position in mm in y direction
        float y{ std::numeric_limits<float>::quiet_NaN() };
        
        void clear() noexcept {
        detX1.markInvalid();
        detX2.markInvalid();
        detY.markInvalid();
        detLogic.markInvalid();
        x = std::numeric_limits<float>::quiet_NaN();
        y = std::numeric_limits<float>::quiet_NaN();
        }
    };
 
 
    struct GeEvent {
        int64_t time{0};
        float e{0};
        float theta{0};
        float phi{0};
    
        // Same as pottu::DetectorEvent.group
        uint16_t group{0};
    
        // Same as pottu::DetectorEvent.coord if addback isn't done
        // If addback is done:
        // Ph1 0-14, clovers 0-23 (Q01, Q02..., Q24)
        // for BEGe: 0-2, fp Clover 0 (w/out addback 0-3)
        uint16_t number{0};
        uint16_t ring{0};
        uint16_t multi{0}; // multiplicity
    };
 
 
    struct FPGeInfo {
        std::vector<pottu::DetectorEvent> beges;
        std::vector<pottu::DetectorEvent> clovers;
        std::vector<GeEvent> gammas;
 
        void clear() noexcept {
        beges.clear();
        clovers.clear();
        gammas.clear();
        };
 
        void fillGammas( bool doCloverAddback = true, int64_t cloverAddbackDuration = 10 ) noexcept;
    };
 
 
    struct GreatFPGeInfo {
        std::vector<pottu::DetectorEvent> planarx;
        std::vector<pottu::DetectorEvent> planary;
        std::vector<pottu::DetectorEvent> clovers;
        std::vector<GeEvent> gammas;
 
        void clear() noexcept {
        planarx.clear();
        planary.clear();
        clovers.clear();
        gammas.clear();
        };
 
        void fillGammas( bool doCloverAddback = true, int64_t cloverAddbackDuration = 10 ) noexcept;
    };
 
 
 
    struct PunchThroughInfo {
        std::vector<pottu::DetectorEvent> events;
 
        void clear() noexcept {
        events.clear();
        }
    };
 
    
    struct TuikeInfo {
        int64_t xtime{0};
        // Position of highest x energy seen
        int16_t x{-1};
        // Position of highest y energy seen
        int16_t y{-1};
        // Summed x energy
        float xe{0};
        // Summed y energy
        float ye{0};
        // Sum of sums
        float sume{0};
    
        std::vector<pottu::DetectorEvent> xbars;
        std::vector<pottu::DetectorEvent> ybars;
    
        void clear() noexcept {
        xtime = 0;
        x=-1;
        y=-1;
        xe=0;
        ye=0;
        sume=0;
        xbars.clear();
        ybars.clear();
        }
 
        void fillFields() noexcept;
    };
 
 
    
    struct BoxInfo {
        std::vector<pottu::DetectorEvent> events;
        
        void clear() noexcept {
        events.clear();
        }
        
    };
    
    
    struct Jurogam3Info {
        std::vector<pottu::DetectorEvent> ph1s; // Raw
        std::vector<pottu::DetectorEvent> clovers; // Raw
        std::vector<GeEvent>              gammas; // Addbacked (or not)
        
        void clear() noexcept {
        ph1s.clear();
        clovers.clear();
        gammas.clear();
        };
        
        void fillGammas( int64_t cloverAddbackDuration, double beta ) noexcept;
 
    };
 
 
    struct Jurogam1Info {
        std::vector<pottu::DetectorEvent> ph1s; // Raw
        std::vector<GeEvent>              gammas; // Addbacked (or not)
        
        void clear() noexcept {
        ph1s.clear();
        gammas.clear();
        };
        
        void fillGammas( double beta ) noexcept;
 
    };
 
    
    struct JYTubeInfo {
        uint16_t fold{0}; // multiplicity
    
        // tube elements
        std::vector<pottu::DetectorEvent> elements;
    
        void clear() noexcept {
        fold = 0;
        elements.clear();
        }
 
        static int8_t getRing(const DetectorEvent &det ) noexcept {
            return det.coord<92 ? jytubeRing[det.coord] : -1;
        }
    };
 
    
    }
 
 
    
}
 
 
 
#endif