wcoef_ids.hpp

Go to the documentation of this file.

#ifndef WCOEF_IDS_H
#define WCOEF_IDS_H
 
#include "generic_mapper.h"
#include "Map.h"
#include "hash_utils.hpp"
#include "GeneralEnum.h"
#include <stdexcept>
#include "LhaID.h"
 
struct WCoefTag {};
 
using WCoefId = SymbolId<WCoefTag>;
 
class WCoefMapper
: public GenericMapperWithExt<
      WCoefTag, WCoef,
      std::pair<int,int>, PairHash,
      wcoef_mapping, wcoef_flha_mapping
  >
{
public:
    using Base = GenericMapperWithExt<WCoefTag,WCoef,std::pair<int,int>,PairHash,wcoef_mapping,wcoef_flha_mapping>;
    using Base::str; using Base::enum_elt; using Base::from_external;
    using Base::external_of; using Base::to_id; using Base::enum_of;
 
    static WCoef from_flha(int a,int b){
        static const auto inv = []{
            std::map<std::pair<int,int>, WCoef> m;
            for (auto& [e,p] : wcoef_flha_mapping()) m.emplace(p,e);
            return m;
        }();
        auto it = inv.find({a,b});
        if (it==inv.end()) throw std::out_of_range("Unsupported FLHA key");
        return it->second;
    }
 
    static std::optional<WCoefId> from_flha_key(int a,int b){ return Base::from_external({a,b}); }
 
    static std::pair<int,int> flha_base(WCoef e){
        return wcoef_flha_mapping().at(canonical_flha_coef(e));
    }
 
    static std::pair<int,int> flha_base(const WCoefId& id){
        if (auto e = enum_of(id)) {
            const WCoef canonical = canonical_flha_coef(*e);
            auto it = wcoef_flha_mapping().find(canonical);
            if (it != wcoef_flha_mapping().end()) return it->second;
        }
 
        auto k = external_of(id);
        if (!k) throw std::runtime_error("No FLHA key for " + id.str());
        return *k; // std::pair<int,int>
    }
 
    static WCoef canonical_flha_coef(WCoef e) {
        switch (e) {
            case WCoef::CQ1:  return WCoef::CQ1_MU;
            case WCoef::CQ2:  return WCoef::CQ2_MU;
            case WCoef::CPQ1: return WCoef::CPQ1_MU;
            case WCoef::CPQ2: return WCoef::CPQ2_MU;
            default: return e;
        }
    }
 
    static LhaID flha_full(WCoef e, QCDOrder q, ContributionType c){
        auto [x,y] = wcoef_flha_mapping().at(canonical_flha_coef(e));
        return LhaID{x,y, int(q)-1, int(c)};
    }
 
    static std::pair<WCoefId, std::pair<QCDOrder, ContributionType>> lha_wilson_deserialize(LhaID id) {
        auto parts = id.get_parts();
        auto w_id = std::make_pair(parts[0], parts[1]);
 
        auto maybe = WCoefMapper::from_flha_key(w_id.first, w_id.second);
        if (!maybe) {
            LOG_ERROR("ValueError", "bad lha id for wilson conversion (unknown custom/base key)");
        }
        WCoefId coef = *maybe;
        QCDOrder order = parts[2] ? ((parts[2] -1) ? QCDOrder::NNLO : QCDOrder::NLO) : QCDOrder::LO;
        ContributionType part = parts[3] ? parts[3] -1 ? ContributionType::TOTAL : ContributionType::BSM : ContributionType::SM;
 
        std::pair<WCoefId, std::pair<QCDOrder, ContributionType>> ret;
        ret = {coef, {order, part}};
 
        return ret;
    }
    static LhaID flha_full(const WCoefId& id, QCDOrder q, ContributionType c){
        if (auto e = enum_of(id)) {
            const WCoef canonical = canonical_flha_coef(*e);
            auto it = wcoef_flha_mapping().find(canonical);
            if (it != wcoef_flha_mapping().end()) {
                return LhaID{it->second.first, it->second.second, int(q)-1, int(c)};
            }
        }
 
        auto k = external_of(id);
        if (!k) throw std::runtime_error("No FLHA key for "+id.str());
        return LhaID{k->first, k->second, int(q)-1, int(c)};
    }
 
    static size_t n_wilsons(){ return wcoef_mapping().size(); }
 
    static const std::map<std::pair<int,int>, WCoef>& inverse_flha_mapping() {
        static const std::map<std::pair<int,int>, WCoef> inv = []{
            std::map<std::pair<int,int>, WCoef> m;
            for (const auto& [e, ab] : wcoef_flha_mapping()) m.emplace(ab, e);
            return m;
        }();
        return inv;
    }
 
    static const std::vector<WCoef>& B_group(){
        static const std::vector<WCoef> g = {
            WCoef::C1,WCoef::C2,WCoef::C3,WCoef::C4,WCoef::C5,WCoef::C6,
            WCoef::C7,WCoef::C8,WCoef::C9,WCoef::C10
        }; return g;
    }
 
    static constexpr int lepton_mass_slot_from_index(int lepton_index) {
        return 31 + lepton_index;
    }
 
    static constexpr int thdm_lepton_yukawa_slot_from_index(int lepton_index) {
        return 101 + lepton_index;
    }
 
    static constexpr int lepton_index_from_pdg(int pdg) {
        return pdg == 11 ? 0 : pdg == 13 ? 1 : pdg == 15 ? 2 : -1;
    }
 
 
    static int lepton_index_from_cq1(WCoef coef) {
        switch (coef) {
            case WCoef::CQ1_E: return 0;
            case WCoef::CQ1_MU:
            case WCoef::CQ1: return 1;
            case WCoef::CQ1_TA: return 2;
            default: throw std::out_of_range("Coefficient is not a CQ1 lepton-specific coefficient");
        }
    }
 
    static int lepton_index_from_cq2(WCoef coef) {
        switch (coef) {
            case WCoef::CQ2_E: return 0;
            case WCoef::CQ2_MU:
            case WCoef::CQ2: return 1;
            case WCoef::CQ2_TA: return 2;
            default: throw std::out_of_range("Coefficient is not a CQ2 lepton-specific coefficient");
        }
    }
 
    static int lepton_index_from_cpq1(WCoef coef) {
        switch (coef) {
            case WCoef::CPQ1_E: return 0;
            case WCoef::CPQ1_MU:
            case WCoef::CPQ1: return 1;
            case WCoef::CPQ1_TA: return 2;
            default: throw std::out_of_range("Coefficient is not a CPQ1 lepton-specific coefficient");
        }
    }
 
    static int lepton_index_from_cpq2(WCoef coef) {
        switch (coef) {
            case WCoef::CPQ2_E: return 0;
            case WCoef::CPQ2_MU:
            case WCoef::CPQ2: return 1;
            case WCoef::CPQ2_TA: return 2;
            default: throw std::out_of_range("Coefficient is not a CPQ2 lepton-specific coefficient");
        }
    }
 
    static WCoef cq1_for_lepton_index(int lepton_index) {
        switch (lepton_index) {
            case 0: return WCoef::CQ1_E;
            case 1: return WCoef::CQ1_MU;
            case 2: return WCoef::CQ1_TA;
            default: throw std::out_of_range("Invalid zero-based lepton generation index for CQ1");
        }
    }
 
    static WCoef cq2_for_lepton_index(int lepton_index) {
        switch (lepton_index) {
            case 0: return WCoef::CQ2_E;
            case 1: return WCoef::CQ2_MU;
            case 2: return WCoef::CQ2_TA;
            default: throw std::out_of_range("Invalid zero-based lepton generation index for CQ2");
        }
    }
 
    static WCoef cpq1_for_lepton_index(int lepton_index) {
        switch (lepton_index) {
            case 0: return WCoef::CPQ1_E;
            case 1: return WCoef::CPQ1_MU;
            case 2: return WCoef::CPQ1_TA;
            default: throw std::out_of_range("Invalid zero-based lepton generation index for CPQ1");
        }
    }
 
    static WCoef cpq2_for_lepton_index(int lepton_index) {
        switch (lepton_index) {
            case 0: return WCoef::CPQ2_E;
            case 1: return WCoef::CPQ2_MU;
            case 2: return WCoef::CPQ2_TA;
            default: throw std::out_of_range("Invalid zero-based lepton generation index for CPQ2");
        }
    }
 
    static bool is_cpq(WCoef c) {
        return c == WCoef::CPQ1_E || c == WCoef::CPQ1_MU || c == WCoef::CPQ1_TA
            || c == WCoef::CPQ2_E || c == WCoef::CPQ2_MU || c == WCoef::CPQ2_TA
            || c == WCoef::CPQ1 || c == WCoef::CPQ2;
    }
 
    static const std::vector<WCoef>& B_prime_group(){
        static const std::vector<WCoef> g = {
            WCoef::CP1,WCoef::CP2,WCoef::CP3,WCoef::CP4,WCoef::CP5,WCoef::CP6,
            WCoef::CP7,WCoef::CP8,WCoef::CP9,WCoef::CP10,
            WCoef::CPQ1_E,WCoef::CPQ1_MU,WCoef::CPQ1_TA,
            WCoef::CPQ2_E,WCoef::CPQ2_MU,WCoef::CPQ2_TA
        }; return g;
    }
 
    static const std::vector<WCoef>& B_scalar_group(){
        static const std::vector<WCoef> g = {
            WCoef::CQ1_E,WCoef::CQ1_MU,WCoef::CQ1_TA,
            WCoef::CQ2_E,WCoef::CQ2_MU,WCoef::CQ2_TA
        }; return g;
    }
 
    static const std::vector<WCoef>& b_clnu_group(){
        static const std::vector<WCoef> g = { WCoef::C_V1_bc, WCoef::C_V2_bc, WCoef::C_S1_bc, WCoef::C_S2_bc, WCoef::C_T_bc }; return g;
    }
 
    static const std::vector<WCoef>& b_ulnu_group(){
        static const std::vector<WCoef> g = { WCoef::C_V1_bu, WCoef::C_V2_bu, WCoef::C_S1_bu, WCoef::C_S2_bu, WCoef::C_T_bu }; return g;
    }
 
    static const std::vector<WCoef>& c_slnu_group(){
        static const std::vector<WCoef> g = { WCoef::C_V1_cs, WCoef::C_V2_cs, WCoef::C_S1_cs, WCoef::C_S2_cs, WCoef::C_T_cs }; return g;
    }
 
    static const std::vector<WCoef>& c_dlnu_group(){
        static const std::vector<WCoef> g = { WCoef::C_V1_cd, WCoef::C_V2_cd, WCoef::C_S1_cd, WCoef::C_S2_cd, WCoef::C_T_cd }; return g;
    }
 
    static const std::vector<WCoef>& s_ulnu_group(){
        static const std::vector<WCoef> g = { WCoef::C_V1_su, WCoef::C_V2_su, WCoef::C_S1_su, WCoef::C_S2_su, WCoef::C_T_su }; return g;
    }
 
    static const std::vector<WCoef>& d_ulnu_group(){
        static const std::vector<WCoef> g = { WCoef::C_V1_du, WCoef::C_V2_du, WCoef::C_S1_du, WCoef::C_S2_du, WCoef::C_T_du}; return g;
    }
 
    static const std::vector<WCoef>& k_group(){
        static const std::vector<WCoef> g = { WCoef::CK9, WCoef::CK10, WCoef::CKQ1, WCoef::CKQ2, WCoef::CK_L, WCoef::CPK9, WCoef::CPK10, WCoef::CPKQ1, WCoef::CPKQ2}; return g;
    }
    
    static const std::vector<WCoef>& meson_mixing_group(){
        static const std::vector<WCoef> g = {
            WCoef::C_BD_1, WCoef::C_BD_2, WCoef::C_BD_3, WCoef::C_BD_4, WCoef::C_BD_5,
            WCoef::CT_BD_1,WCoef::CT_BD_2,WCoef::CT_BD_3,
            WCoef::C_BS_1, WCoef::C_BS_2, WCoef::C_BS_3, WCoef::C_BS_4, WCoef::C_BS_5,
            WCoef::CT_BS_1,WCoef::CT_BS_2,WCoef::CT_BS_3,
            WCoef::C_SD_1, WCoef::C_SD_2, WCoef::C_SD_3, WCoef::C_SD_4, WCoef::C_SD_5,
            WCoef::CT_SD_1,WCoef::CT_SD_2,WCoef::CT_SD_3,
            WCoef::C_CU_1, WCoef::C_CU_2, WCoef::C_CU_3, WCoef::C_CU_4, WCoef::C_CU_5,
            WCoef::CT_CU_1,WCoef::CT_CU_2,WCoef::CT_CU_3
        }; return g;
    }
 
    static std::vector<WCoef> get_group(WGroup g){
        switch (g){
            case WGroup::B: return {B_group().begin(), B_group().end()};
            case WGroup::BPrime: return {B_prime_group().begin(), B_prime_group().end()};
            case WGroup::BScalar: return {B_scalar_group().begin(), B_scalar_group().end()};
            case WGroup::CC_bc: return {b_clnu_group().begin(), b_clnu_group().end()};
            case WGroup::CC_bu: return {b_ulnu_group().begin(), b_ulnu_group().end()};
            case WGroup::CC_cs: return {c_slnu_group().begin(), c_slnu_group().end()};
            case WGroup::CC_cd: return {c_dlnu_group().begin(), c_dlnu_group().end()};
            case WGroup::CC_su: return {s_ulnu_group().begin(), s_ulnu_group().end()};
            case WGroup::CC_du: return {d_ulnu_group().begin(), d_ulnu_group().end()};
            case WGroup::K:     return {k_group().begin(), k_group().end()};
            case WGroup::MESON_MIXING: return {meson_mixing_group().begin(), meson_mixing_group().end()};
            default: LOG_ERROR("Invalid WGroup","get_group couldn't find your group"); return {};
        }
    }
 
    static WGroup group_of(WCoef c){
        if (c == WCoef::CQ1 || c == WCoef::CQ2) return WGroup::BScalar;
        if (c == WCoef::CPQ1 || c == WCoef::CPQ2) return WGroup::BPrime;
 
        static const std::map<WCoef, WGroup> inv = []{
            std::map<WCoef, WGroup> m;
 
            auto add = [&](WGroup g, const std::vector<WCoef>& v){
                for (auto e : v) {
                    // optional safety: detect duplicates across groups
                    if (m.find(e) != m.end())
                        throw std::runtime_error("WCoef appears in multiple WGroups");
                    m.emplace(e, g);
                }
            };
 
            add(WGroup::B,            B_group());
            add(WGroup::BPrime,       B_prime_group());
            add(WGroup::BScalar,      B_scalar_group());
            add(WGroup::CC_bc,        b_clnu_group());
            add(WGroup::CC_bu,        b_ulnu_group());
            add(WGroup::CC_cs,        c_slnu_group());
            add(WGroup::CC_cd,        c_dlnu_group());
            add(WGroup::CC_su,        s_ulnu_group());
            add(WGroup::CC_du,        d_ulnu_group());
            add(WGroup::K,            k_group());
            add(WGroup::MESON_MIXING, meson_mixing_group());
 
            return m;
        }();
 
        auto it = inv.find(c);
        if (it == inv.end()) throw std::out_of_range("WCoef not assigned to any WGroup");
        return it->second;
    }
 
    static std::optional<WGroup> group_of_opt(WCoef c){
        try { return group_of(c); }
        catch (...) { return std::nullopt; }
    }
 
    static WGroup group_of(const WCoefId& id){
        auto e = enum_of(id);
        if (!e) throw std::runtime_error("Unknown WCoefId: " + id.str());
        return group_of(*e);
    }
};
 
#endif