kernels.hpp

#pragma once

#include <functional>

#include "particle.hpp"

namespace wash {
    using ForceFuncT = std::function<void(Particle&, const std::vector<Particle>::const_iterator&,
                                          const std::vector<Particle>::const_iterator&)>;
    using UpdateFuncT = std::function<void(Particle&)>;
    using MapFuncT = std::function<double(const Particle&)>;
    using VoidFuncT = std::function<void()>;
    using NeighborsFuncT = std::function<void(Particle&)>;

    enum class ReduceOp { max, min, sum, prod };

    class Kernel {
    public:
        virtual ~Kernel() = default;
        virtual void exec() const = 0;
    };

    class ForceKernel : public Kernel {
    private:
        ForceFuncT func;

    public:
        ForceKernel(const ForceFuncT func) : func(func) {}

        virtual void exec() const override;
    };

    class UpdateKernel : public Kernel {
    private:
        UpdateFuncT func;

    public:
        UpdateKernel(const UpdateFuncT func) : func(func) {}

        virtual void exec() const override;
    };

    class ReductionKernel : public Kernel {
    private:
        MapFuncT map_func;
        ReduceOp reduce_op;
        double* variable;

    public:
        ReductionKernel(const MapFuncT map_func, const ReduceOp reduce_op, double* variable)
            : map_func(map_func), reduce_op(reduce_op), variable(variable) {}

        virtual void exec() const override;
    };

    class VoidKernel : public Kernel {
    private:
        VoidFuncT func;

    public:
        VoidKernel(const VoidFuncT func) : func(func) {}

        virtual void exec() const override;
    };
}