alcor_finedata.h

#pragma once
 
#include <mist/ring_finding/hough_transform.h>
#include <sstream>
#include <cmath>
#include <iostream>
#include <fstream>
#include <unordered_map>
#include <array>
#include "TH2F.h"
#include "TF1.h"
#include "TCanvas.h"
#include "alcor_data.h"
 
struct alcor_finedata_struct
{
 
    uint32_t rollover;
 
    uint16_t coarse;
 
    uint8_t fine;
 
    float hit_x;
 
    float hit_y;
 
 
 
    uint32_t global_index;
 
    uint32_t hit_mask;
 
 
    alcor_finedata_struct() = default;
 
    alcor_finedata_struct(uint32_t rollover_,
                          uint16_t coarse_,
                          uint8_t fine_,
                          float hit_x_,
                          float hit_y_,
                          uint32_t global_index_,
                          uint32_t hit_mask_)
        : rollover(rollover_),
          coarse(coarse_),
          fine(fine_),
          hit_x(hit_x_),
          hit_y(hit_y_),
          global_index(global_index_),
          hit_mask(hit_mask_)
    {
    }
 
    alcor_finedata_struct(const alcor_data_struct &d);
};
 
// =============================================================================
 
class alcor_finedata
{
public:
    // -------------------------------------------------------------------------
    // Constructors
    // -------------------------------------------------------------------------
 
    alcor_finedata();
 
    alcor_finedata(const alcor_finedata_struct &s);
 
    alcor_finedata(const alcor_data_struct &d);
 
    alcor_finedata(const alcor_finedata &o);
 
    // -------------------------------------------------------------------------
    // Getters — Raw fields
    // -------------------------------------------------------------------------
 
 
    alcor_finedata_struct get_data_struct() const { return internal_data; }
 
    uint32_t get_global_index() const { return internal_data.global_index; }
 
    uint32_t get_rollover() const { return internal_data.rollover; }
 
    uint16_t get_coarse() const { return internal_data.coarse; }
 
    uint8_t get_fine() const { return internal_data.fine; }
 
    float get_hit_x() const { return internal_data.hit_x; }
 
    float get_hit_y() const { return internal_data.hit_y; }
 
    uint32_t get_mask() const { return internal_data.hit_mask; }
 
 
    // -------------------------------------------------------------------------
    // Getters — Derived timing
    // -------------------------------------------------------------------------
 
 
    float get_phase() const;
 
    float get_time() const
    {
        return static_cast<float>(_ALCOR_ROLLOVER_TO_CC_) * static_cast<float>(get_rollover()) + static_cast<float>(get_coarse()) - get_phase();
    }
 
    float get_time_ns() const { return _ALCOR_CC_TO_NS_ * get_time(); }
 
 
    // -------------------------------------------------------------------------
    // Getters — Derived channel address
    // -------------------------------------------------------------------------
 
 
    int get_tdc() const { return get_global_index() % 4; }
 
    int get_device() const { return 192 + (get_global_channel_index() / 256); }
 
    int get_fifo() const { return (get_global_channel_index() % 256) / 8; }
 
    int get_chip() const { return (get_global_channel_index() % 256) / 32; }
 
    int get_eo_channel() const { return (get_global_channel_index() % 256) % 32 + 32 * (get_chip() % 2); }
 
    int get_column() const { return ((get_global_channel_index() % 256) % 32) / 4; }
 
    int get_pixel() const { return ((get_global_channel_index() % 256) % 32) % 4; }
 
    int get_device_index() const { return get_eo_channel() + 64 * (get_chip() / 2); }
 
    int get_global_channel_index() const { return get_global_index() / 4; }
 
 
    // -------------------------------------------------------------------------
    // Getters — Spatial (randomised)
    // -------------------------------------------------------------------------
 
 
    float get_hit_x_rnd() const { return internal_data.hit_x + (_rnd_(_global_gen_) * 3.0f - 1.5f); }
 
    float get_hit_y_rnd() const { return internal_data.hit_y + (_rnd_(_global_gen_) * 3.0f - 1.5f); }
 
    float get_hit_r_rnd() const { return get_hit_r_rnd({0.f, 0.f}); }
 
    float get_hit_phi_rnd() const { return get_hit_phi_rnd({0.f, 0.f}); }
 
    float get_hit_r_rnd(std::array<float, 2> v) const;
 
    float get_hit_phi_rnd(std::array<float, 2> v) const;
 
 
    // -------------------------------------------------------------------------
    // Getters — Hit masks
    // -------------------------------------------------------------------------
 
 
    void add_mask_bit(hit_mask bit) { internal_data.hit_mask |= (1u << bit); }
 
    void clear_mask_bit(hit_mask bit) { internal_data.hit_mask &= ~(1u << bit); }
 
    bool has_mask_bit(hit_mask bit) const { return (internal_data.hit_mask >> bit) & 1u; }
 
    bool is_ring_tag_first() const { return has_mask_bit(_HITMASK_ring_tag_first); }
 
    bool is_ring_tag_second() const { return has_mask_bit(_HITMASK_ring_tag_second); }
 
    bool is_cross_talk() const { return has_mask_bit(_HITMASK_cross_talk); }
 
    bool is_afterpulse() const { return has_mask_bit(_HITMASK_afterpulse); }
 
    bool is_part_lane() const { return has_mask_bit(_HITMASK_part_lane); }
 
    bool is_dead_lane() const { return has_mask_bit(_HITMASK_dead_lane); }
 
 
    // -------------------------------------------------------------------------
    // Setters — Raw fields
    // -------------------------------------------------------------------------
 
 
    void set_data_struct(const alcor_finedata_struct &d) { internal_data = d; }
 
    void set_global_index(uint32_t calib) { internal_data.global_index = calib; }
 
    void set_rollover(uint32_t r) { internal_data.rollover = r; }
 
    void set_coarse(uint16_t c) { internal_data.coarse = c; }
 
    void set_fine(uint8_t f) { internal_data.fine = f; }
 
    void set_mask(uint32_t mask) { internal_data.hit_mask = mask; }
 
    void set_streaming_ring_trigger_mask() { add_mask_bit(_HITMASK_streaming_ring_trigger_); }
 
 
    // -------------------------------------------------------------------------
    // Setters — Calibration parameters
    // -------------------------------------------------------------------------
 
 
    static void set_param0(int global_tdc_index, float value) { calibration_parameters[global_tdc_index][0] = value; }
 
    static void set_param1(int global_tdc_index, float value) { calibration_parameters[global_tdc_index][1] = value; }
 
    static void set_param2(int global_tdc_index, float value) { calibration_parameters[global_tdc_index][2] = value; }
 
 
    // -------------------------------------------------------------------------
    // Comparison operators
    // -------------------------------------------------------------------------
 
 
    bool operator<(const alcor_finedata &v) const { return get_time() < v.get_time(); }
 
    bool operator<=(const alcor_finedata &v) const { return get_time() <= v.get_time(); }
 
    bool operator>(const alcor_finedata &v) const { return get_time() > v.get_time(); }
 
    bool operator>=(const alcor_finedata &v) const { return get_time() >= v.get_time(); }
 
 
    // -------------------------------------------------------------------------
    // Calibration I/O
    // -------------------------------------------------------------------------
 
 
    void generate_calibration(TH2F *calibration_histogram, bool overwrite_calibration);
 
    void update_calibration(TH2F *h) { generate_calibration(h, false); }
 
    void write_calib_to_file(const std::string &filename);
 
    void read_calib_from_file(const std::string &filename, bool clear_first = true, bool overwrites = true);
 
 
    // -------------------------------------------------------------------------
    // Finding rings algorithms
    // -------------------------------------------------------------------------
 
 
    static std::vector<mist::ring_finding::ring_result> alcor_find_rings_hough(
        mist::ring_finding::hough_transform &ht,
        std::vector<alcor_finedata> &alcor_hits,
        float threshold_fraction,
        int min_hits,
        int min_active,
        int max_rings = 2,
        float collection_radius = 6.f);
 
 
private:
    // -------------------------------------------------------------------------
    // Private data
    // -------------------------------------------------------------------------
 
    alcor_finedata_struct internal_data;
 
    inline static std::unordered_map<int, std::array<float, 3>> calibration_parameters = {};
 
    // -------------------------------------------------------------------------
    // Private helpers
    // -------------------------------------------------------------------------
 
    void set_standard_function();
};