LambdaDecay.h

Go to the documentation of this file.

#ifndef LAMBDA_DECAY_H
#define LAMBDA_DECAY_H
 
#include <any>
#include <functional>
#include <optional>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
 
#include "DecayParent.h"
#include "CustomWilsonLambda.h"
#include "mapper_hub.hpp"
 
class LambdaDecay;
 
using LambdaObservableComputer =
    std::function<std::vector<ObservableValue>(LambdaDecay&, ObservableId)>;
 
using LambdaDecayLoadHook = std::function<void(LambdaDecay&)>;
 
using LambdaDecayConfigureHook = std::function<void(LambdaDecay&, const std::any&)>;
 
struct LambdaObservableConfig {
    std::string canonical;
 
    std::vector<std::string> aliases {};
 
    std::optional<LhaID> flha = std::nullopt;
 
    std::unordered_set<ParamId> dependencies {};
 
    LambdaObservableComputer compute {};
 
    LambdaObservableConfig() = default;
 
    LambdaObservableConfig(std::string canonical_, LambdaObservableComputer compute_)
        : canonical(std::move(canonical_)), compute(std::move(compute_)) {}
 
    static LambdaObservableConfig scalar(
        std::string canonical_,
        std::function<double(LambdaDecay&, ObservableId)> compute_
    ) {
        LambdaObservableConfig out;
        out.canonical = std::move(canonical_);
        out.compute = [fn = std::move(compute_)](LambdaDecay& ctx, ObservableId id) {
            return std::vector<ObservableValue>{ObservableValue(id, fn(ctx, id))};
        };
        return out;
    }
 
    static LambdaObservableConfig binned_scalar(
        std::string canonical_,
        std::function<double(LambdaDecay&, std::pair<double,double>, ObservableId)> compute_
    );
};
 
struct LambdaDecayConfig {
    std::string canonical;
 
    std::vector<std::string> aliases {};
 
    double matching_scale = 81.0;
 
    double hadronic_scale = 4.8;
 
    QCDOrder order = QCDOrder::LO;
 
    QCDOrder max_order = QCDOrder::NNLO;
 
    std::unordered_set<WGroupId> wilson_groups {};
 
    std::vector<CustomWilsonGroupConfig> custom_wilson_groups {};
 
    std::vector<LambdaObservableConfig> observables {};
 
    bool propagate_custom_wilson_dependencies {true};
 
    LambdaDecayLoadHook load_params {};
 
    LambdaDecayConfigureHook configure {};
};
 
class LambdaDecay : public DecayParent {
public:
    LambdaDecay(DecayId id, LambdaDecayConfig config, ObservablePortsConfig& ports)
        : DecayParent(id, config.matching_scale, config.hadronic_scale, config.order, ports),
          config_(std::move(config))
    {
        this->max_order = config_.max_order;
        this->w_config.groups = config_.wilson_groups;
 
        for (const auto& custom_group : config_.custom_wilson_groups) {
            this->w_config.groups.insert(custom_group.group);
        }
 
        for (const auto& obs : config_.observables) {
            if (!obs.compute) {
                LOG_ERROR("ValueError", "Lambda observable", obs.canonical, "has no compute function.");
            }
            computers_.emplace(ObservableMapper::id_of(obs.canonical), obs.compute);
        }
    }
 
    void load_params() override {
        if (config_.load_params) {
            config_.load_params(*this);
        }
    }
 
    std::vector<ObservableValue> compute_observable(Observables obs) override {
        return compute_observable(ObservableMapper::to_id(obs));
    }
 
    std::vector<ObservableValue> compute_observable(ObservableId obs) override {
        auto it = computers_.find(obs);
        if (it == computers_.end()) {
            LOG_ERROR("KeyError", "Lambda decay", DecayMapper::str(this->id),
                      "does not contain observable", ObservableMapper::str(obs));
        }
        return it->second(*this, obs);
    }
 
    void set_config(std::any cfg) override {
        runtime_config_ = std::move(cfg);
        if (config_.configure) {
            config_.configure(*this, runtime_config_);
        }
    }
 
    const LambdaDecayConfig& config() const { return config_; }
 
    const std::any& user_config() const { return runtime_config_; }
 
    bool has_user_config() const { return runtime_config_.has_value(); }
 
    IObsWilsonProxy& W() {
        if (!this->w_proxy) {
            LOG_ERROR("LogicError", "Wilson proxy is not available before LambdaDecay is enabled.");
        }
        return *this->w_proxy;
    }
 
    std::shared_ptr<IObsWilsonProxy> wilson_proxy() {
        if (!this->w_proxy) {
            LOG_ERROR("LogicError", "Wilson proxy is not available before LambdaDecay is enabled.");
        }
        return this->w_proxy;
    }
 
    IObsParameterProxy<ParamId, DataType, std::string, LhaID>& SM() { return *this->p; }
 
    IObsParameterProxy<ParamId, DataType, std::string, LhaID>& FLAVOR() { return *this->ports.iobspp_flav; }
 
    IObsQCDProxy& QCD() { return *this->iobs_qcdp; }
 
    ObservablePortsConfig& observable_ports() { return this->ports; }
 
    std::optional<std::vector<std::pair<double,double>>> current_bins() { return this->get_bins(); }
 
private:
    LambdaDecayConfig config_;
    std::any runtime_config_;
    std::unordered_map<ObservableId, LambdaObservableComputer> computers_;
};
 
inline LambdaObservableConfig LambdaObservableConfig::binned_scalar(
    std::string canonical_,
    std::function<double(LambdaDecay&, std::pair<double,double>, ObservableId)> compute_
) {
    LambdaObservableConfig out;
    out.canonical = std::move(canonical_);
    out.compute = [fn = std::move(compute_)](LambdaDecay& ctx, ObservableId id) {
        std::vector<ObservableValue> values;
        auto bins = ctx.current_bins();
        if (!bins.has_value() || bins->empty()) {
            values.emplace_back(id, fn(ctx, {0.0, 0.0}, id));
            return values;
        }
 
        values.reserve(bins->size());
        for (const auto& bin : *bins) {
            values.emplace_back(id, fn(ctx, bin, id), bin);
        }
        return values;
    };
    return out;
}
 
#endif // LAMBDA_DECAY_H