kernel.hpp

#pragma once
 
#include <span>
#include <string_view>
 
namespace excgrid {


struct XcKernelValue {
    double exc = 0.0; 
    double vrhoA = 0.0; 
    double vrhoB = 0.0; 
    double vsigmaAa = 0.0; 
    double vsigmaAb = 0.0; 
    double vsigmaBb = 0.0; 
    double vtauA = 0.0; 
    double vtauB = 0.0; 
};

constexpr XcKernelValue operator+(const XcKernelValue& a, const XcKernelValue& b) noexcept {
    return {a.exc + b.exc,
            a.vrhoA + b.vrhoA,
            a.vrhoB + b.vrhoB,
            a.vsigmaAa + b.vsigmaAa,
            a.vsigmaAb + b.vsigmaAb,
            a.vsigmaBb + b.vsigmaBb,
            a.vtauA + b.vtauA,
            a.vtauB + b.vtauB};
}

constexpr XcKernelValue& operator+=(XcKernelValue& a, const XcKernelValue& b) noexcept {
    a = a + b;
 
    return a;
}

constexpr XcKernelValue operator*(double weight, const XcKernelValue& v) noexcept {
    return {weight * v.exc,
            weight * v.vrhoA,
            weight * v.vrhoB,
            weight * v.vsigmaAa,
            weight * v.vsigmaAb,
            weight * v.vsigmaBb,
            weight * v.vtauA,
            weight * v.vtauB};
}

constexpr XcKernelValue operator*(const XcKernelValue& v, double weight) noexcept {
    return weight * v;
}

using LdaKernel = XcKernelValue (*)(double rhoA, double rhoB);

using GgaKernel =
    XcKernelValue (*)(double rhoA, double rhoB, double sigmaAa, double sigmaAb, double sigmaBb);

class XcFunctional {
public:
    virtual ~XcFunctional() = default;

    [[nodiscard]] virtual bool UsesGradient() const = 0;

    [[nodiscard]] virtual double ExchangeFraction() const = 0;

    virtual XcKernelValue Evaluate(
        double rhoA, double rhoB, double sigmaAa, double sigmaAb, double sigmaBb) const = 0;
};

const XcFunctional* FindFunctional(std::string_view name) noexcept;

std::span<const std::string_view> FunctionalNames() noexcept;
 
} // namespace excgrid