alcor_spilldata.h

#pragma once
 
#include <vector>
#include <iostream>
#include <cstdint>
#include <unordered_map>
#include <map>
 
#include "alcor_lightdata.h"
#include "TH1.h"
#include "TTree.h"
#include "triggers.h"
 
// ============================================================================
//  Data structures
// ============================================================================
 
struct data_mask_struct
{
    uint8_t device; 
    uint32_t mask;  
};
 
struct alcor_spilldata_struct
{
    // --- Special members ------------------------------------------------
    alcor_spilldata_struct() noexcept = default;
 
    alcor_spilldata_struct(alcor_spilldata_struct &&) noexcept = default;
    alcor_spilldata_struct &operator=(alcor_spilldata_struct &&) noexcept = default;
 
    alcor_spilldata_struct(const alcor_spilldata_struct &) = default;
    alcor_spilldata_struct &operator=(const alcor_spilldata_struct &) = default;
 
    // --- Working maps (random-access processing) ------------------------
    std::map<uint8_t, uint32_t> dead_mask;                          
    std::map<uint8_t, uint32_t> participants_mask;                  
    std::map<uint32_t, alcor_lightdata_struct> frame_and_lightdata; 
 
    // --- Flat vectors (ROOT TTree serialisation) -------------------------
    std::vector<data_mask_struct> dead_mask_list;                
    std::vector<data_mask_struct> participants_mask_list;        
    std::vector<uint32_t> frame_reference;                       
    std::vector<alcor_lightdata_struct> lightdata_list_in_frame; 
 
    // --- Branch-address pointers (ROOT internal use) --------------------
    //  @warning These are intentionally NOT initialised here. Taking the address
    //           of a sibling member in a default member initialiser is UB, and
    //           after any copy/move the pointers would dangle into the source
    //           object. They are set correctly by clear() and prepare_tree_fill().
    std::vector<data_mask_struct> *dead_mask_list_ptr;                
    std::vector<data_mask_struct> *participants_mask_list_ptr;        
    std::vector<uint32_t> *frame_reference_ptr;                       
    std::vector<alcor_lightdata_struct> *lightdata_list_in_frame_ptr; 
 
    void clear();
};
 
// ============================================================================
//  alcor_spilldata class
// ============================================================================
 
class alcor_spilldata : public alcor_lightdata
{
public:
    // -----------------------------------------------------------------------
    //  Constructors
    // -----------------------------------------------------------------------
 
    alcor_spilldata() { spilldata.clear(); }
 
    explicit alcor_spilldata(const alcor_spilldata_struct &v) : spilldata(v) {}
 
    // -----------------------------------------------------------------------
    //  Getters — by value (deep copy)
    // -----------------------------------------------------------------------
 
    alcor_spilldata_struct get_spilldata() const { return spilldata; }
 
    std::map<uint32_t, alcor_lightdata_struct> get_frame() const { return spilldata.frame_and_lightdata; }
 
    std::map<uint8_t, uint32_t> get_participants_mask() const { return spilldata.participants_mask; }
 
    std::map<uint8_t, uint32_t> get_dead_mask() const { return spilldata.dead_mask; }
 
    std::vector<alcor_lightdata_struct> get_frame_list() const { return spilldata.lightdata_list_in_frame; }
 
    std::vector<uint32_t> get_frame_reference_list() const { return spilldata.frame_reference; }
 
    // -----------------------------------------------------------------------
    //  Getters — by reference (zero-copy, caller must not outlive this object)
    // -----------------------------------------------------------------------
 
    alcor_spilldata_struct &get_spilldata_link() { return spilldata; }
 
    std::map<uint32_t, alcor_lightdata_struct> &get_frame_link() { return spilldata.frame_and_lightdata; }
 
    std::map<uint8_t, uint32_t> &get_participants_mask_link() { return spilldata.participants_mask; }
 
    std::map<uint8_t, uint32_t> &get_dead_mask_link() { return spilldata.dead_mask; }
 
    std::vector<alcor_lightdata_struct> &get_frame_list_link() { return spilldata.lightdata_list_in_frame; }
 
    std::vector<uint32_t> &get_frame_reference_list_link() { return spilldata.frame_reference; }
 
    // -----------------------------------------------------------------------
    //  Per-frame hit-vector getters
    // -----------------------------------------------------------------------
 
    std::vector<trigger_event> &get_frame_trigger_hits(uint32_t index_of_frame) { return spilldata.frame_and_lightdata[index_of_frame].trigger_hits; }
 
    std::vector<alcor_finedata_struct> &get_frame_timing_hits(uint32_t index_of_frame) { return spilldata.frame_and_lightdata[index_of_frame].timing_hits; }
 
    std::vector<alcor_finedata_struct> &get_frame_tracking_hits(uint32_t index_of_frame) { return spilldata.frame_and_lightdata[index_of_frame].tracking_hits; }
 
    std::vector<alcor_finedata_struct> &get_frame_cherenkov_hits(uint32_t index_of_frame) { return spilldata.frame_and_lightdata[index_of_frame].cherenkov_hits; }
 
    // -----------------------------------------------------------------------
    //  Setters — by value (deep copy)
    // -----------------------------------------------------------------------
 
    void set_spilldata(alcor_spilldata_struct v) { spilldata = v; }
 
    void set_frame(std::map<uint32_t, alcor_lightdata_struct> v) { spilldata.frame_and_lightdata = v; }
 
    void set_participants_mask(std::map<uint8_t, uint32_t> v) { spilldata.participants_mask = v; }
 
    void set_dead_mask(std::map<uint8_t, uint32_t> v) { spilldata.dead_mask = v; }
 
    // -----------------------------------------------------------------------
    //  Setters — by reference (moves/aliases the source)
    // -----------------------------------------------------------------------
 
    void set_spilldata_link(alcor_spilldata_struct &v) { spilldata = v; }
 
    void set_frame_link(std::map<uint32_t, alcor_lightdata_struct> &v) { spilldata.frame_and_lightdata = v; }
 
    void set_participants_mask_link(std::map<uint8_t, uint32_t> &v) { spilldata.participants_mask = v; }
 
    void set_dead_mask_link(std::map<uint8_t, uint32_t> &v) { spilldata.dead_mask = v; }
 
    // -----------------------------------------------------------------------
    //  Utility methods
    // -----------------------------------------------------------------------
 
    void clear()
    {
        spilldata.clear();
        frame_reference_for_deletion.clear();
    }
 
    bool has_trigger(uint32_t index_of_frame) { return !spilldata.frame_and_lightdata[index_of_frame].trigger_hits.empty(); }
 
    void add_trigger_to_frame(uint32_t index_of_frame, trigger_event trg) { spilldata.frame_and_lightdata[index_of_frame].trigger_hits.push_back(trg); }
 
    void do_not_write_frame(uint32_t index_of_frame) { frame_reference_for_deletion[index_of_frame] = true; }
 
    std::map<uint32_t, std::vector<uint8_t>> get_not_dead_participants();
 
    bool has_data() { return !spilldata.participants_mask.empty() || !spilldata.participants_mask_list.empty(); }
 
    // -----------------------------------------------------------------------
    //  ROOT TTree I/O
    // -----------------------------------------------------------------------
 
    void link_to_tree(TTree *input_tree);
 
    void write_to_tree(TTree *output_tree);
 
    void prepare_tree_fill();
 
    void get_entry() {}
 
private:
    alcor_spilldata_struct spilldata;                                
    std::unordered_map<uint32_t, bool> frame_reference_for_deletion; 
};
 
// ============================================================================
//  Free-function merge / reduce utilities
// ============================================================================
 
void merge_lightdata(alcor_lightdata_struct &lhs, alcor_lightdata_struct &&rhs);
 
void merge(alcor_spilldata_struct &lhs, alcor_spilldata_struct &&rhs);
 
void merge(alcor_spilldata &lhs, alcor_spilldata &&rhs);
 
alcor_spilldata_struct operator+(alcor_spilldata_struct lhs, alcor_spilldata_struct rhs);
 
alcor_spilldata operator+(alcor_spilldata lhs, const alcor_spilldata &rhs);