WilsonGroup.h

Go to the documentation of this file.

#ifndef WILSON_GROUP_H
#define WILSON_GROUP_H
 
#include <unordered_map>
#include <optional>
 
#include "Include.h"
#include "Utils.h"
#include "Wilson.h"
#include "IBlockComposer.h"
#include "ICoreAPI.h"
#include "IMartyWilsonProxy.h"
#include "config.hpp"
#include "InterpretedParam.h"
#include "WilsonGroupAdapterConfig.h"
 
struct CoefficientGroupSources {
    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&)> func =
        [](const auto&, const auto&) { return std::unordered_map<WCoefId, scalar_t>(); };
};
 
 
class CoefficientGroup : public std::map<std::string, std::shared_ptr<WilsonCoefficient>> {
public:
    CoefficientGroup(WilsonGroupAdapterConfig adapters) : adapters(adapters) {};
 
    CoefficientGroup(const CoefficientGroup&);
 
    CoefficientGroup(CoefficientGroup&&) = default;
 
    CoefficientGroup(std::map<std::string, std::shared_ptr<WilsonCoefficient>>& coeffs, WilsonGroupAdapterConfig adapters);
 
    void init(QCDOrder order);
 
    void init_full_running_block(const std::unordered_map<ParameterType, std::vector<std::string>> &source_names, WilsonBasis basis, bool inter, std::vector<ContributionType> type);
 
    virtual std::shared_ptr<CoefficientGroup> get_sm_group() {LOG_ERROR("LogicError", "cannot get_sm_group for virtual group"); return nullptr;}
 
    complex_t get_matching_coefficient(std::string coeff, std::string order, ContributionType cont_type) const;
 
    complex_t get_running_coefficient(std::string coeff, std::string order, ContributionType cont_type, WilsonBasis basis = WilsonBasis::B_STANDARD) const;
 
    QCDOrder get_order();
 
    std::string get_matching_storage_block() const { return block_name; }
 
    void set_matching_storage_block(std::string);
 
    ContributionType get_type() {return this->wilson_type;}
 
    std::unordered_map<ParameterType, std::vector<std::string>> get_sources(QCDOrder ord, WilsonBasis id) {return this->sources[id][ord].sources;}
 
    std::unordered_set<WilsonBasis> get_bases() const {
        return get_keys(this->sources);
    }
 
    std::function<std::unordered_map<WCoefId, scalar_t>(const std::unordered_map<QCDOrder, std::unordered_map<WCoefId, scalar_t>>&, const BlockSrc&)> get_func(QCDOrder ord, WilsonBasis id) {return this->sources[id][ord].func;}
 
    WGroupId get_group_id() const {return id;}
 
    const std::vector<WCoefId>& get_member_ids() const { return member_ids; }
 
    void set_member_ids(std::vector<WCoefId> ids) { member_ids = std::move(ids); }
 
    void add_member_id(WCoefId id);
 
    void set_group_id(WGroupId gid) { id = gid; }
 
    void set_wilson_type(ContributionType ct) { wilson_type = ct; }
 
    void add_sources(WilsonBasis basis, const std::map<QCDOrder, CoefficientGroupSources>& m) {
        sources[basis] = m;
    }
    
    virtual std::shared_ptr<CoefficientGroup> clone() const = 0;
 
    virtual ~CoefficientGroup() = default;
 
protected:
    void claim_coefficients();
 
    ContributionType wilson_type {ContributionType::SM};
 
    QCDOrder current_order = QCDOrder::LO;
 
    WGroupId id;
 
    std::string block_name;
 
    std::vector<WCoefId> member_ids;
 
    std::map<WilsonBasis, std::map<QCDOrder, CoefficientGroupSources>> sources;
 
    WilsonGroupAdapterConfig adapters;
};
 
std::ostream& operator<<(std::ostream& os, const CoefficientGroup& coeffs);
 
std::ostream& operator<<(std::ostream& os, const std::shared_ptr<CoefficientGroup>& coeffs);
 
#endif // WILSON_GROUP_H