triggers.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <vector>
#include <cstdint>
#include <iostream>
#include <toml++/toml.h>
#include "TH2.h"
 
// ============================================================
//  Trigger enum & compile-time metadata
// ============================================================
 
enum trigger_number : uint8_t
{
    _TRIGGER_FIRST_FRAMES_ = 100,         
    _TRIGGER_TIMING_ = 101,               
    _TRIGGER_TRACKING_ = 102,             
    _TRIGGER_RING_FOUND_ = 103,           
    _TRIGGER_STREAMING_RING_FOUND_ = 104, 
    _TRIGGER_HOUGH_RING_FOUND_ = 105,     
    _TRIGGER_START_OF_SPILL_ = 200,       
    _TRIGGER_UNKNOWN_ = 255               
};
 
constexpr trigger_number all_default_triggers[] = {
    _TRIGGER_FIRST_FRAMES_,
    _TRIGGER_TIMING_,
    _TRIGGER_TRACKING_,
    _TRIGGER_RING_FOUND_,
    _TRIGGER_STREAMING_RING_FOUND_,
    _TRIGGER_HOUGH_RING_FOUND_,
    _TRIGGER_START_OF_SPILL_,
    _TRIGGER_UNKNOWN_};
 
constexpr const char *default_names[] = {
    "FIRST_FRAMES", "TIMING", "TRACKING",
    "RING_FOUND", "STREAMING_RING_FOUND",
    "HOUGH_RING_FOUND",
    "START_OF_SPILL", "UNKNOWN"};
 
constexpr int n_default_triggers = std::size(all_default_triggers);
 
constexpr int default_trigger_index(trigger_number t)
{
    for (int i = 0; i < n_default_triggers; ++i)
        if (all_default_triggers[i] == t)
            return i;
    return -1;
}
 
// ============================================================
//  Data structs
// ============================================================
 
struct trigger_event
{
    uint8_t index;   
    uint16_t coarse; 
    float fine_time; 
 
    trigger_event() = default;
 
    trigger_event(uint8_t idx)
        : index(idx), coarse(0), fine_time(0.f) {}
 
    trigger_event(uint8_t idx, uint16_t crs)
        : index(idx), coarse(crs), fine_time(0.f) {}
 
    trigger_event(uint8_t idx, uint16_t crs, float fine)
        : index(idx), coarse(crs), fine_time(fine) {}
};
 
struct trigger_config
{
    std::string name; 
    uint8_t index;    
    uint16_t delay;   
    uint16_t device;  
 
    trigger_config() = default;
 
    trigger_config(const std::string &_name,
                   uint8_t _index,
                   uint16_t _delay,
                   uint16_t _device)
        : name(_name), index(_index), delay(_delay), device(_device) {}
};
 
// ============================================================
//  Runtime trigger registry
// ============================================================
 
struct trigger_registry
{
    std::vector<std::pair<uint8_t, std::string>> triggers;
 
    trigger_registry() = default;
 
    explicit trigger_registry(const std::vector<trigger_config> &config_triggers)
    {
        for (const auto &t : config_triggers)
            triggers.push_back({t.index, t.name});
        for (int i = 0; i < n_default_triggers; ++i)
            triggers.push_back({all_default_triggers[i], default_names[i]});
    }
 
    int index_of(uint8_t trigger_value) const
    {
        for (int i = 0; i < static_cast<int>(triggers.size()); ++i)
            if (triggers[i].first == trigger_value)
                return i;
 
        std::cerr << "[WARN] trigger_registry: unknown trigger value "
                  << static_cast<int>(trigger_value)
                  << " — falling back to UNKNOWN\n";
        return default_trigger_index(_TRIGGER_UNKNOWN_);
    }
 
    std::string name_of(uint8_t trigger_value) const
    {
        return triggers[index_of(trigger_value)].second;
    }
 
    int size() const { return static_cast<int>(triggers.size()); }
 
    void label_axes(TH2F *h) const
    {
        for (int i = 0; i < static_cast<int>(triggers.size()); ++i)
        {
            h->GetXaxis()->SetBinLabel(i + 1, triggers[i].second.c_str());
            h->GetYaxis()->SetBinLabel(i + 1, triggers[i].second.c_str());
        }
    }
};
 
// ============================================================
//  TOML config reader
// ============================================================
 
inline std::vector<trigger_config>
trigger_conf_reader(const std::string &config_file = "Data/triggers.toml")
{
    std::vector<trigger_config> triggers;
 
    toml::table tbl;
    try
    {
        tbl = toml::parse_file(config_file);
    }
    catch (const toml::parse_error &e)
    {
        std::cerr << "[ERROR] Failed to parse trigger config \"" << config_file
                  << "\": " << e.description() << "\n";
        return triggers;
    }
 
    std::cout << "[INFO] Loaded trigger config: " << config_file << "\n";
 
    auto arr = tbl.get_as<toml::array>("trigger");
    if (!arr)
    {
        std::cerr << "[WARN] No [[trigger]] entries found in \"" << config_file << "\"\n";
        return triggers;
    }
 
    // Tracks which indices in [0, 99] are already claimed.
    // Flat bool array: O(1) insert/lookup, trivially sized for 100 slots.
    bool used_indices[100] = {};
 
    // Returns the earliest free slot in [0, 99], or -1 if all are taken.
    auto earliest_free = [&]() -> int
    {
        for (int i = 0; i < 100; ++i)
            if (!used_indices[i])
                return i;
        return -1;
    };
 
    for (const auto &node : *arr)
    {
        const auto *entry = node.as_table();
        if (!entry)
            continue;
 
        // Validate all required keys are present
        if (!entry->contains("name") || !entry->contains("index") ||
            !entry->contains("device") || !entry->contains("delay"))
        {
            std::cerr << "[WARN] Skipping incomplete [[trigger]] entry (missing required key)\n";
            continue;
        }
 
        trigger_config cfg;
        cfg.name = entry->at("name").value_or(std::string{});
        uint16_t raw_index = static_cast<uint16_t>(entry->at("index").value_or(0));
        cfg.device = static_cast<uint16_t>(entry->at("device").value_or(0));
        cfg.delay = static_cast<uint16_t>(entry->at("delay").value_or(0));
 
        // Enforce [0, 99] index range — [100, 255] is reserved for built-in triggers.
        // Also catches duplicates: an already-used in-range index is treated the same
        // as an out-of-range one and gets reassigned to the earliest free slot.
        bool out_of_range = raw_index > 99;
        bool duplicate = !out_of_range && used_indices[raw_index];
 
        if (out_of_range || duplicate)
        {
            int free_slot = earliest_free();
            if (free_slot == -1)
            {
                std::cerr << "[ERROR] \"" << cfg.name << "\""
                          << (duplicate ? " has duplicate index " : " has out-of-range index ")
                          << raw_index
                          << " and no free slot remains in [0, 99] — entry dropped\n";
                continue;
            }
 
            std::cerr << "[WARN] \"" << cfg.name << "\""
                      << (duplicate ? " has duplicate index " : " has out-of-range index ")
                      << raw_index << " (valid range: 0-99, unique)"
                      << " — reassigned to earliest available index " << free_slot << "\n";
            raw_index = static_cast<uint16_t>(free_slot);
        }
 
        cfg.index = static_cast<uint8_t>(raw_index);
        used_indices[cfg.index] = true;
        triggers.push_back(cfg);
 
        std::cout << "[INFO]  " << cfg.name
                  << " | index=" << static_cast<int>(cfg.index)
                  << " | device=" << cfg.device
                  << " | delay=" << cfg.delay << "\n";
    }
 
    return triggers;
}