alcor_data.h

Go to the documentation of this file.

#pragma once
 
#include "TTree.h"
#include "utility.h"
 
#define _ALCOR_CC_TO_NS_ 3.125
#define _ALCOR_ROLLOVER_TO_CC_ 32768
 
struct alcor_data_struct
{
    int device;        
    int fifo;          
    int type;          
    int counter;       
    int column;        
    int pixel;         
    int tdc;           
    int rollover;      
    int coarse;        
    int fine;          
    uint32_t hit_mask; 
 
    alcor_data_struct() = default;
};
 
enum alcor_hit_struct
{
    alcor_hit = 1,
    trigger_tag = 9,
    start_spill = 7,
    end_spill = 15
};
 
enum hit_mask
{
    _HITMASK_streaming_ring_trigger_ = 1,
    _HITMASK_ring_tag_first = 2,
    _HITMASK_ring_tag_second = 3,
    _HITMASK_hough_ring_tag_first = 11,
    _HITMASK_hough_ring_tag_second = 12,
    _HITMASK_cross_talk = 28,
    _HITMASK_afterpulse = 29,
    _HITMASK_part_lane = 30,
    _HITMASK_dead_lane = 31
};
 
class alcor_data
{
private:
    alcor_data_struct data;
    static constexpr int rollover_to_clock = _ALCOR_ROLLOVER_TO_CC_;
    static constexpr double coarse_to_ns = _ALCOR_CC_TO_NS_;
    static constexpr int rollover_to_ns = rollover_to_clock * coarse_to_ns;
 
public:
    alcor_data() = default; 
 
    explicit alcor_data(const alcor_data_struct &data_struct) : data(data_struct) {}
 
    explicit alcor_data(int device, int fifo, int type, int counter,
                        int column, int pixel, int tdc, int rollover,
                        int coarse, int fine, uint32_t mask)
    {
        data.device = device;
        data.fifo = fifo;
        data.type = type;
        data.counter = counter;
        data.column = column;
        data.pixel = pixel;
        data.tdc = tdc;
        data.rollover = rollover;
        data.coarse = coarse;
        data.fine = fine;
        data.hit_mask = mask;
    }
 
    alcor_data_struct get_data_struct() const { return data; } 
    int get_device() const { return data.device; }             
    int get_fifo() const { return data.fifo; }                 
    int get_type() const { return data.type; }                 
    int get_counter() const { return data.counter; }           
    int get_column() const { return data.column; }             
    int get_pixel() const { return data.pixel; }               
    int get_tdc() const { return data.tdc; }                   
    int get_rollover() const { return data.rollover; }         
    int get_coarse() const { return data.coarse; }             
    int get_fine() const { return data.fine; }                 
    uint32_t get_mask() const { return data.hit_mask; }        
 
    int get_chip() const { return data.fifo / 4; }                                              
    int get_eo_channel() const { return data.pixel + 4 * data.column + 32 * (get_chip() % 2); } 
    int get_calib_index() const { return data.tdc + 4 * get_eo_channel() + 128 * get_chip(); }  
    int get_device_index() const { return get_eo_channel() + 64 * (get_chip() / 2); }           
    int get_global_index() const { return get_device_index() + 256 * (get_device() - 192); }    
    int get_global_tdc_index() const { return 4 * get_global_index() + get_tdc(); }             
    uint64_t get_coarse_global_time() const { return get_coarse() + get_rollover() * rollover_to_clock; }
 
    void set_data_struct_copy(alcor_data_struct input_data) { data = input_data; }    
    void set_data_struct_linked(alcor_data_struct &input_data) { data = input_data; } 
    void set_device(int val) { data.device = val; }                                   
    void set_fifo(int val) { data.fifo = val; }                                       
    void set_type(int val) { data.type = val; }                                       
    void set_counter(int val) { data.counter = val; }                                 
    void set_column(int val) { data.column = val; }                                   
    void set_pixel(int val) { data.pixel = val; }                                     
    void set_tdc(int val) { data.tdc = val; }                                         
    void set_rollover(int val) { data.rollover = val; }                               
    void set_coarse(int val) { data.coarse = val; }                                   
    void set_fine(int val) { data.fine = val; }                                       
    void set_fine(uint32_t val) { data.fine = static_cast<int>(val); }                
    void set_mask(uint32_t val) { data.hit_mask = val; }                              
 
    bool operator<(const alcor_data &c) const { return coarse_time_ns() < c.coarse_time_ns(); }
    bool operator<=(const alcor_data &c) const { return coarse_time_ns() <= c.coarse_time_ns(); }
    bool operator>(const alcor_data &c) const { return coarse_time_ns() > c.coarse_time_ns(); }
    bool operator>=(const alcor_data &c) const { return coarse_time_ns() >= c.coarse_time_ns(); }
 
    bool is_alcor_hit() const { return get_type() == alcor_hit; }     
    bool is_trigger_tag() const { return get_type() == trigger_tag; } 
    bool is_start_spill() const { return get_type() == start_spill; } 
    bool is_end_spill() const { return get_type() == end_spill; }     
 
    int coarse_time_clock() const { return get_coarse() + get_rollover() * rollover_to_clock; }             
    double coarse_time_ns() const { return get_coarse() * coarse_to_ns + get_rollover() * rollover_to_ns; } 
 
    void add_mask(uint32_t new_mask) { data.hit_mask |= new_mask; }     
    void add_mask_bit(int new_mask) { add_mask(encode_bit(new_mask)); } 
 
 
    void link_to_tree(TTree *input_tree);
    void write_to_tree(TTree *output_tree);
};