CustomWilsonGroup.h

Go to the documentation of this file.

#ifndef CUSTOM_WILSON_GROUP_H
#define CUSTOM_WILSON_GROUP_H
 
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
#include <utility>
 
#include "WilsonGroup.h"
 
class CustomCoefficientGroup : public CoefficientGroup {
public:
    explicit CustomCoefficientGroup(WilsonGroupAdapterConfig adapters, WGroupId gid, const std::string& name,
                                    ContributionType type = ContributionType::SM)
    : CoefficientGroup(adapters) {
        this->id = gid;
        this->name_grp = name;
        this->wilson_type = type;
    }
 
    std::shared_ptr<CoefficientGroup> clone() const override {
        return std::make_shared<CustomCoefficientGroup>(*this);
    }
 
    CustomCoefficientGroup& add_coefficient(const std::shared_ptr<WilsonCoefficient>& coef) {
        this->insert({coef->get_name(), coef});
        this->add_member_id(WCoefMapper::id_of(coef->get_base_name()));
        return *this;
    }
 
    CustomCoefficientGroup& add_coefficient(WCoefId id, const std::shared_ptr<WilsonCoefficient>& coef) {
        this->insert({WCoefMapper::str(id), coef});
        this->add_member_id(std::move(id));
        return *this;
    }
 
    CustomCoefficientGroup& set_basis_order_sources_and_running(
        WilsonBasis basis,
        QCDOrder order,
        std::unordered_map<ParameterType, std::vector<std::string>> source_names,
        std::function<std::unordered_map<WCoefId, scalar_t>(
            const std::unordered_map<QCDOrder, std::unordered_map<WCoefId, scalar_t>>&,
            const BlockSrc&
        )> running_func
    ) {
        sources[basis][order].sources = std::move(source_names);
        sources[basis][order].func    = std::move(running_func);
        if (order > current_order) current_order = order;
        return *this;
    }
 
    static std::unordered_map<WCoefId, scalar_t> identity_running(
        const std::unordered_map<QCDOrder, std::unordered_map<WCoefId, scalar_t>>& coef_matching,
        const BlockSrc& /*src*/
    ) {
        QCDOrder best = QCDOrder::LO;
        if (coef_matching.count(QCDOrder::NNLO)) best = QCDOrder::NNLO;
        else if (coef_matching.count(QCDOrder::NLO)) best = QCDOrder::NLO;
 
        return coef_matching.at(best);
    }
 
    CustomCoefficientGroup& finalize(QCDOrder order) {
        this->init(order);
        return *this;
    }
    
    std::string name_grp;
};
 
#endif // CUSTOM_WILSON_GROUP_H