alcor_recodata.h

Go to the documentation of this file.

#pragma once
 
#include <iostream>
#include <vector>
#include <array>
#include <map>
#include <cmath>
#include <sstream>
#include "TTree.h"
#include "triggers.h"
#include "alcor_spilldata.h"
#include "alcor_finedata.h"
#include "parallel_streaming_framer.h"
 
// ============================================================
//  alcor_recodata
// ============================================================
 
class alcor_recodata
{
private:
    std::vector<trigger_event> triggers;                  
    std::vector<trigger_event> *triggers_ptr = &triggers; 
 
    std::vector<alcor_finedata_struct> recodata;                  
    std::vector<alcor_finedata_struct> *recodata_ptr = &recodata; 
 
    // ---- Hough-transform internals ----------------------------------------
    std::vector<float> hough_r_bins; 
    float hough_cell_size = 3.2f;    
    float hough_x_min;               
    float hough_x_max;               
    float hough_y_min;               
    float hough_y_max;               
    int hough_nx;                    
    int hough_ny;                    
    std::vector<int> hough_accum;    
    std::unordered_map<int, std::vector<std::vector<int>>> hough_lut;
 
public:
    // ================================================================
    //  Constructors
    // ================================================================
 
    alcor_recodata() = default;
 
    explicit alcor_recodata(const std::vector<alcor_finedata_struct> &d);
 
    // ================================================================
 
 
    inline std::vector<alcor_finedata_struct> get_recodata() const { return recodata; }
 
    inline std::vector<alcor_finedata_struct> *get_recodata_ptr() { return recodata_ptr; }
 
    inline alcor_finedata_struct get_recodata(int i) const { return recodata[i]; }
 
    inline std::vector<alcor_finedata_struct> &get_recodata_link() { return recodata; }
 
    inline alcor_finedata_struct &get_recodata_link(int i) { return recodata[i]; }
 
    inline alcor_finedata get_finedata(int i) const { return alcor_finedata(recodata[i]); }
 
    inline std::vector<trigger_event> get_triggers() const { return triggers; }
 
    inline std::vector<trigger_event> *get_triggers_ptr() { return triggers_ptr; }
 
    inline std::vector<trigger_event> &get_triggers_link() { return triggers; }
 
 
    // ================================================================
 
 
    inline uint32_t get_global_index(int i) const { return recodata[i].global_index; }
 
    inline float get_hit_x(int i) const { return recodata[i].hit_x; }
 
    inline float get_hit_y(int i) const { return recodata[i].hit_y; }
 
    inline uint32_t get_hit_mask(int i) const { return recodata[i].hit_mask; }
 
    inline float get_hit_t(int i) const { return get_finedata(i).get_time_ns(); }
 
    inline float get_hit_r(int i) const { return get_hit_r(i, {0.f, 0.f}); }
 
    inline float get_hit_r(int i, std::array<float, 2> v) const { return std::hypot(get_hit_x(i) - v[0], get_hit_y(i) - v[1]); }
 
    inline float get_hit_phi(int i) const { return get_hit_phi(i, {0.f, 0.f}); }
 
    inline float get_hit_phi(int i, std::array<float, 2> v) const { return std::atan2(get_hit_y(i) - v[1], get_hit_x(i) - v[0]); }
 
    inline float get_hit_x_rnd(int i) const { return recodata[i].hit_x + (_rnd_(_global_gen_) * 3.0f - 1.5f); }
 
    inline float get_hit_y_rnd(int i) const { return recodata[i].hit_y + (_rnd_(_global_gen_) * 3.0f - 1.5f); }
 
    inline float get_hit_r_rnd(int i) const { return get_hit_r_rnd(i, {0.f, 0.f}); }
 
    inline float get_hit_r_rnd(int i, std::array<float, 2> v) const { return std::hypot(get_hit_x_rnd(i) - v[0], get_hit_y_rnd(i) - v[1]); }
 
    inline float get_hit_phi_rnd(int i) const { return get_hit_phi_rnd(i, {0.f, 0.f}); }
 
    inline float get_hit_phi_rnd(int i, std::array<float, 2> v) const { return std::atan2(get_hit_y_rnd(i) - v[1], get_hit_x_rnd(i) - v[0]); }
 
 
    // ================================================================
 
 
    inline int get_hit_tdc(int i) const { return get_finedata(i).get_tdc(); }
 
    inline int get_device(int i) const { return get_finedata(i).get_device(); }
 
    inline int get_fifo(int i) const { return get_finedata(i).get_fifo(); }
 
    inline int get_chip(int i) const { return get_finedata(i).get_chip(); }
 
    inline int get_eo_channel(int i) const { return get_finedata(i).get_eo_channel(); }
 
    inline int get_column(int i) const { return get_finedata(i).get_column(); }
 
    inline int get_pixel(int i) const { return get_finedata(i).get_pixel(); }
 
    inline int get_device_index(int i) const { return get_finedata(i).get_device_index(); }
 
    inline int get_global_channel_index(int i) const { return get_finedata(i).get_global_channel_index(); }
 
 
    // ================================================================
 
 
    std::optional<trigger_event> get_trigger_by_index(uint8_t index) const;
 
    inline std::optional<trigger_event> get_timing_trigger() const { return get_trigger_by_index(_TRIGGER_TIMING_); }
 
 
    // ================================================================
 
 
    inline void set_recodata(std::vector<alcor_finedata_struct> v) { recodata = v; }
 
    inline void set_recodata(int i, alcor_finedata_struct v) { recodata[i] = v; }
 
    inline void set_triggers(const std::vector<trigger_event> v) { triggers = v; }
 
    inline void set_recodata_ptr(std::vector<alcor_finedata_struct> *v) { recodata_ptr = v; }
 
    inline void set_triggers_ptr(std::vector<trigger_event> *v) { triggers_ptr = v; }
 
    inline void set_global_index(int i, uint32_t v) { recodata[i].global_index = v; }
 
    inline void set_hit_x(int i, float v) { recodata[i].hit_x = v; }
 
    inline void set_hit_y(int i, float v) { recodata[i].hit_y = v; }
 
    inline void set_hit_mask(int i, uint32_t v) { recodata[i].hit_mask = v; }
 
    void set_recodata_link(std::vector<alcor_finedata_struct> &v);
 
    void set_triggers_link(std::vector<trigger_event> &v);
 
 
    // ================================================================
 
 
    inline void add_hit_mask(int i, uint32_t v) { recodata[i].hit_mask |= v; }
 
    inline void add_hit_mask_bit(int i, uint32_t v) { recodata[i].hit_mask |= encode_bit(v); }
 
    inline void add_trigger(uint8_t index, uint16_t coarse, float fine_time = 0.) { triggers.emplace_back(index, coarse, fine_time); }
 
    inline void add_trigger(trigger_event hit) { triggers.push_back(hit); }
 
    inline int add_hit(const alcor_finedata_struct &hit)
    {
        recodata_ptr->push_back(hit);
        return recodata_ptr->size() - 1;
    }
 
    inline int add_hit(const alcor_finedata &hit)
    {
        recodata_ptr->push_back(hit.get_data_struct());
        return recodata_ptr->size() - 1;
    }
 
    inline int add_hit(uint32_t rollover,
                       uint16_t coarse,
                       uint8_t fine,
                       float hit_x,
                       float hit_y,
                       uint32_t global_index,
                       uint32_t hit_mask)
    {
        recodata_ptr->emplace_back(rollover, coarse, fine, hit_x, hit_y, global_index, hit_mask);
        return recodata_ptr->size() - 1;
    }
 
 
    // ================================================================
 
 
    inline bool check_trigger(uint8_t v) { return get_trigger_by_index(v).has_value(); }
 
    inline bool is_start_of_spill() { return check_trigger(_TRIGGER_START_OF_SPILL_); }
 
    inline bool is_first_frames() { return check_trigger(_TRIGGER_FIRST_FRAMES_); }
 
    inline bool is_timing_available() { return check_trigger(_TRIGGER_TIMING_); }
 
    inline bool is_embedded_tracking_available() { return check_trigger(_TRIGGER_TRACKING_); }
 
    inline bool is_ring_found() { return check_trigger(_TRIGGER_RING_FOUND_); }
 
    inline bool check_hit_mask(int i, uint32_t v) { return (get_hit_mask(i) & v) != 0; }
 
    inline bool is_afterpulse(int i) { return get_finedata(i).is_afterpulse(); }
 
    inline bool is_cross_talk(int i) { return get_finedata(i).is_cross_talk(); }
 
    inline bool is_ring_tagged(int i) { return check_hit_mask(i, encode_bits({_HITMASK_ring_tag_first, _HITMASK_ring_tag_second})); }
 
 
    // ================================================================
 
 
    void clear();
 
    bool link_to_tree(TTree *input_tree);
 
    void write_to_tree(TTree *output_tree);
 
 
    // ================================================================
 
 
    void find_rings(float_t distance_length_cut, float_t distance_time_cut);
 
    void build_hough_lut(const std::map<int, std::array<float, 2>> &index_to_hit_xy,
                         float r_min, float r_max, float r_step, float cell_size);
 
    void find_rings_hough(float threshold_fraction, int min_hits);
 
};