grid.hpp

#pragma once
 
#include "excgrid/error.hpp"
#include "excgrid/geometry.hpp"
#include "excgrid/internal/lebedev_tables.hpp"
 
#include <array>
#include <cstddef>
#include <span>
#include <vector>
 
namespace excgrid {


class RadialGrid {
public:
    static Result<RadialGrid> Create(std::size_t pointCount,
                                     double alpha,
                                     std::size_t exponent = 2);

    [[nodiscard]] std::size_t Size() const noexcept {
        return _points.size();
    }

    [[nodiscard]] std::span<const double> Points() const noexcept {
        return _points;
    }

    [[nodiscard]] std::span<const double> Weights() const noexcept {
        return _weights;
    }
 
private:
    RadialGrid(std::vector<double> points, std::vector<double> weights) noexcept;
 
    std::vector<double> _points;
    std::vector<double> _weights;
};

class AngularGrid {
public:
    static constexpr std::span<const std::size_t, internal::kLebedevSizeCount> kAvailableSizes =
        internal::kLebedevSizes;

    static Result<AngularGrid> Create(std::size_t pointCount);

    [[nodiscard]] std::size_t Size() const noexcept {
        return _size;
    }

    [[nodiscard]] std::size_t Degree() const noexcept {
        return _degree;
    }

    [[nodiscard]] std::array<double, 3> Point(std::size_t index) const noexcept;

    [[nodiscard]] double Weight(std::size_t index) const noexcept;
 
private:
    AngularGrid(std::size_t size, std::size_t degree, std::size_t offset) noexcept;
 
    std::size_t _size;
    std::size_t _degree;
    std::size_t _offset;
};

struct GridParams {
    std::size_t radialPoints = 75; 
    std::size_t angularPoints = 302; 
    double alpha = 0.5; 
    std::size_t radialExponent = 2; 
    double trimWeight = 1e-15; 
    std::size_t blockTarget = 1024; 
};

struct Block {
    std::size_t pointCount = 0; 
    std::vector<std::array<double, 3>> points; 
    std::vector<double> weights; 
    std::vector<std::size_t> atomIndex; 
};

class BlockGrid {
public:
    static Result<BlockGrid> Create(const Geometry& geometry, const GridParams& params = {});

    [[nodiscard]] std::size_t BlockCount() const noexcept {
        return _blocks.size();
    }

    [[nodiscard]] std::span<const Block> Blocks() const noexcept {
        return _blocks;
    }

    [[nodiscard]] std::size_t TotalPointCount() const noexcept {
        return _totalPoints;
    }
 
private:
    BlockGrid(std::vector<Block> blocks, std::size_t totalPoints) noexcept;
 
    std::vector<Block> _blocks;
    std::size_t _totalPoints;
};
 
} // namespace excgrid