CustomWilsonLambda.h

Go to the documentation of this file.

#ifndef CUSTOM_WILSON_LAMBDA_H
#define CUSTOM_WILSON_LAMBDA_H
 
#include <map>
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
 
#include "CustomWilson.h"
#include "CustomWilsonGroup.h"
#include "WilsonBlockNames.h"
 
struct CustomWilsonCoefficientConfig {
    WCoefId id;
 
    std::map<QCDOrder, MatchingInfo> matching;
 
    CustomWilsonCoefficientConfig() = default;
    explicit CustomWilsonCoefficientConfig(WCoefId id) : id(std::move(id)) {}
 
    CustomWilsonCoefficientConfig& set_matching(
        QCDOrder order,
        std::unordered_set<ParamId> sources,
        std::function<scalar_t(const ParamSrc&)> compute,
        ContributionType contribution = ContributionType::SM
    ) {
        matching[order] = MatchingInfo(
            std::move(sources),
            std::move(compute),
            WCoefMapper::flha_full(id, order, contribution)
        );
        return *this;
    }
};
 
struct CustomWilsonGroupConfig {
    WGroupId group;
 
    std::string display_name;
 
    double matching_scale {81.0};
 
    double hadronic_scale {4.8};
 
    QCDOrder order {QCDOrder::LO};
 
    ContributionType contribution {ContributionType::SM};
 
    std::vector<CustomWilsonCoefficientConfig> coefficients;
 
    std::unordered_map<WilsonBasis, std::map<QCDOrder, CoefficientGroupSources>> running;
 
    bool install_identity_running_if_empty {true};
 
    CustomWilsonGroupConfig() = default;
    explicit CustomWilsonGroupConfig(WGroupId group) : group(std::move(group)) {}
 
    CustomWilsonGroupConfig& add_coefficient(CustomWilsonCoefficientConfig coef) {
        coefficients.emplace_back(std::move(coef));
        return *this;
    }
 
    CustomWilsonGroupConfig& set_running(
        WilsonBasis basis,
        QCDOrder order,
        std::unordered_map<ParameterType, std::vector<std::string>> sources,
        std::function<std::unordered_map<WCoefId, scalar_t>(
            const std::unordered_map<QCDOrder, std::unordered_map<WCoefId, scalar_t>>&,
            const BlockSrc&
        )> compute
    ) {
        CoefficientGroupSources s;
        s.sources = std::move(sources);
        s.func = std::move(compute);
        running[basis][order] = std::move(s);
        return *this;
    }
};
 
inline std::unordered_map<WCoefId, scalar_t> custom_identity_running(
    const std::unordered_map<QCDOrder, std::unordered_map<WCoefId, scalar_t>>& matching,
    const BlockSrc&
) {
    if (auto it = matching.find(QCDOrder::NNLO); it != matching.end()) return it->second;
    if (auto it = matching.find(QCDOrder::NLO);  it != matching.end()) return it->second;
    if (auto it = matching.find(QCDOrder::LO);   it != matching.end()) return it->second;
    return {};
}
 
inline std::shared_ptr<CustomCoefficientGroup> make_custom_wilson_group(
    const CustomWilsonGroupConfig& cfg,
    WilsonGroupAdapterConfig adapters
) {
    const std::string name = cfg.display_name.empty() ? GroupMapper::str(cfg.group) : cfg.display_name;
    auto group = std::make_shared<CustomCoefficientGroup>(adapters, cfg.group, name, cfg.contribution);
    group->set_matching_storage_block(WilsonBlockNames::matching(cfg.group));
    group->set_wilson_type(cfg.contribution);
 
    for (const auto& coef_cfg : cfg.coefficients) {
        auto coef = std::make_shared<CustomWilson>(
            coef_cfg.id,
            WilsonBlockNames::matching(cfg.group),
            cfg.contribution
        );
 
        for (auto order : {QCDOrder::LO, QCDOrder::NLO, QCDOrder::NNLO}) {
            auto it = coef_cfg.matching.find(order);
            if (it != coef_cfg.matching.end()) {
                coef->set_order_info(order, it->second.sources, it->second.compute, it->second.lhaid);
            } else {
                coef->set_order_info(
                    order,
                    {},
                    [](const ParamSrc&) { return 0.0; },
                    WCoefMapper::flha_full(coef_cfg.id, order, cfg.contribution)
                );
            }
        }
 
        group->add_coefficient(coef_cfg.id, coef);
    }
 
    if (!cfg.running.empty()) {
        for (const auto& [basis, per_order] : cfg.running) {
            group->add_sources(basis, per_order);
        }
    } else if (cfg.install_identity_running_if_empty) {
        std::map<QCDOrder, CoefficientGroupSources> per_order;
        for (auto order : {QCDOrder::LO, QCDOrder::NLO, QCDOrder::NNLO}) {
            CoefficientGroupSources s;
            s.sources = {{ParameterType::WILSON, {WilsonBlockNames::matching(cfg.group)}}};
            s.func = &custom_identity_running;
            per_order[order] = std::move(s);
        }
        group->add_sources(WilsonBasis::B_STANDARD, per_order);
    }
 
    return group;
}
 
#endif // CUSTOM_WILSON_LAMBDA_H