decay_ids.hpp

Go to the documentation of this file.

#ifndef DECAY_IDS_H
#define DECAY_IDS_H
 
#include <algorithm>
#include <mutex>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
 
#include "generic_mapper.h"
#include "Map.h"
#include "LhaID.h"
#include "observable_ids.hpp"
 
struct DecayTag {};
 
using DecayId = IdOf<DecayTag>;
 
inline const std::map<Decays, LhaID>& decay_external_mapping() {
    static const std::map<Decays, LhaID> empty{};
    return empty;
}
 
struct CustomObservableSpec {
    std::string canonical;                  
    std::vector<std::string> aliases{};     
    std::optional<LhaID> ext = std::nullopt; 
};
 
class DecayMapper
: public GenericMapperWithExt<
      DecayTag,
      Decays,
      LhaID,
      std::hash<LhaID>,
      decays_mapping,
      decay_external_mapping
  >
{
public:
    using Base = GenericMapperWithExt<
        DecayTag,
        Decays,
        LhaID,
        std::hash<LhaID>,
        decays_mapping,
        decay_external_mapping
    >;
 
    using Base::init_builtins;
    using Base::id_of;           
    using Base::enum_elt;        
    using Base::str;             
    using Base::to_id;           
    using Base::enum_of;         
    using Base::list_all;
    using Base::from_external;
    using Base::external_of;
    using Base::set_external;
 
    static bool register_custom(std::string canonical,
                                std::vector<std::string> aliases = {},
                                std::optional<LhaID> ext = std::nullopt) = delete;
 
    static std::vector<Observables> get_observables(Decays d) {
        return decay_observable_mapping().at(d);
    }
 
    static std::vector<ObservableId> get_observable_ids(Decays d) {
        std::vector<ObservableId> out;
        const auto& obs_enums = decay_observable_mapping().at(d);
        out.reserve(obs_enums.size());
 
        for (auto obs : obs_enums) {
            out.push_back(ObservableMapper::to_id(obs));
        }
 
        return out;
    }
 
    static std::vector<ObservableId> get_observables(const DecayId& d) {
        std::vector<ObservableId> out;
        std::unordered_set<ObservableId> seen;
 
        auto add = [&](const ObservableId& obs) {
            if (seen.insert(obs).second) {
                out.push_back(obs);
            }
        };
 
        for (const auto& obs : DecayGraph::instance().observables_of(d)) {
            add(obs);
        }
 
        if (auto builtin = enum_of(d); builtin) {
            for (const auto& obs : get_observable_ids(*builtin)) {
                add(obs);
            }
        }
 
        if (out.empty()) {
            throw std::runtime_error("Decay has no observable: " + d.str());
        }
 
        return out;
    }
 
    static std::vector<ObservableId> get_observables(std::string_view d) {
        return get_observables(id_of(d));
    }
 
    static bool has_observables(const DecayId& d) {
        if (DecayGraph::instance().has_observables(d)) {
            return true;
        }
 
        if (auto builtin = enum_of(d); builtin) {
            auto it = decay_observable_mapping().find(*builtin);
            return it != decay_observable_mapping().end() && !it->second.empty();
        }
 
        return false;
    }
 
    static void require_observables(const DecayId& d) {
        if (!has_observables(d)) {
            throw std::runtime_error("Decay must have at least one observable: " + d.str());
        }
    }
 
    static bool register_custom_with_observables(std::string canonical,
                                                 std::vector<std::string> aliases,
                                                 std::vector<CustomObservableSpec> observables)
    {
        if (observables.empty()) {
            throw std::invalid_argument(
                "Cannot register custom decay '" + canonical + "' without observables"
            );
        }
 
        const bool ok = Base::register_custom(canonical, std::move(aliases), std::nullopt);
        if (!ok) {
            return false;
        }
 
        const DecayId decay_id = Base::id_of(canonical);
 
        for (auto& obs : observables) {
            ObservableMapper::register_custom(
                obs.canonical,
                std::move(obs.aliases),
                std::move(obs.ext),
                decay_id
            );
        }
 
        return true;
    }
 
    static Decays get_decay(Observables obs) {
        for (const auto& [d, vec] : decay_observable_mapping()) {
            if (std::find(vec.begin(), vec.end(), obs) != vec.end()) {
                return d;
            }
        }
        throw std::runtime_error("Observable not mapped to any decay");
    }
 
    inline static const std::unordered_map<ObservableId, DecayId>& observable_to_decay() {
        static std::unordered_map<ObservableId, DecayId> cache;
        static std::once_flag init;
 
        std::call_once(init, [] {
            for (const auto& [decayEnum, vec] : decay_observable_mapping()) {
                DecayId did = DecayMapper::to_id(decayEnum);
                for (auto o : vec) {
                    cache.emplace(ObservableMapper::to_id(o), did);
                }
            }
        });
 
        return cache;
    }
 
    inline static std::optional<DecayId> get_decay_id(const ObservableId& obs) {
        if (auto d = DecayGraph::instance().parent_of(obs); d) {
            return d;
        }
 
        const auto& m = observable_to_decay();
        if (auto it = m.find(obs); it != m.end()) {
            return it->second;
        }
 
        return std::nullopt;
    }
 
    inline static std::optional<DecayId> get_decay_id(Observables obs) {
        return get_decay_id(ObservableMapper::to_id(obs));
    }
 
    inline static DecayId get_decay_id_or_throw(const ObservableId& obs) {
        auto d = get_decay_id(obs);
        if (!d) {
            throw std::runtime_error("Observable not mapped to any decay: " + obs.str());
        }
        return *d;
    }
};
 
#endif // DECAY_IDS_H