plain_wave_generator.hh

#ifndef VTESTBED_CORE_PLAIN_WAVE_GENERATOR_HH
#define VTESTBED_CORE_PLAIN_WAVE_GENERATOR_HH

#include <any>
#include <cmath>
#include <memory>
#include <stdexcept>
#include <vector>

#include <vtestbed/base/blitz.hh>
#include <vtestbed/base/for_loop.hh>
#include <vtestbed/core/grid.hh>
#include <vtestbed/core/policy.hh>
#include <vtestbed/core/types.hh>
#include <vtestbed/core/wavy_surface_generator.hh>

namespace vtb {

    namespace core {

        template <class T, int N, class Wave>
        inline void
        generate_wave(const Grid<T,N>& grid, Array<T,N>& result, Wave wave) {
            #if defined(VTB_DEBUG)
            if (!blitz::all(result.shape() == grid.shape())) {
                throw std::invalid_argument("vtb::core::generate_wave: bad result shape");
            }
            #endif
            const auto delta{grid.delta()};
            parallel_for_loop<N>(
                grid.begin(),
                grid.end(),
                [&result,&grid,&wave,&delta](const blitz::TinyVector<int,N>& idx) {
                    blitz::TinyVector<T,N> v{grid(idx, delta)};
                    blitz::TinyVector<T,N-1> x;
                    for (int i=1; i<N; ++i) { x(i-1) = v(i); }
                    result(idx) = wave(x, v(0));
                }
            );
        }

        template <class T, int N, class Wave>
        inline Array<T,N>
        generate_wave(const Grid<T,N>& grid, Wave wave) {
            Array<T,N> result(grid.shape());
            generate_wave<T,N,Wave>(grid, result, wave);
            return result;
        }

        template <class T, int N, class Wave, Policy P=Policy::OpenMP>
        class Plain_wave_generator: public Wavy_surface_generator<T,N> {

        private:
            using base_type = Wavy_surface_generator<T,N>;

        public:
            using typename base_type::grid_type;
            using typename base_type::array_type;
            using wave_type = Wave;

        private:
            Wave _wave;

        public:

            Plain_wave_generator() = default;
            Plain_wave_generator(const Plain_wave_generator&) = default;
            Plain_wave_generator&
            operator=(const Plain_wave_generator&) = default;
            inline explicit Plain_wave_generator(const Wave& wave): _wave(wave) {}

            virtual void
            generate(const grid_type& grid, array_type& result) = 0;

            inline const Wave& wave() const { return this->_wave; }

            inline grid_type acf_grid() const override { return this->_wave.acf_grid(); }

        };

        template <class T, int N, class Wave, Policy P>
        std::unique_ptr<Plain_wave_generator<T,N,Wave,P>>
        make_plain_wave_generator(const Wave& wave);

        template <class T, int N, class Wave, Policy P>
        std::unique_ptr<Plain_wave_generator<T,N,Wave,P>>
        make_plain_wave_generator();

        template <class T, int N>
        std::unique_ptr<Wavy_surface_generator<T,N>>
        make_plain_wave_generator(std::any wave, Policy policy);

        template <class T, int N>
        class Irregular_wave_surface_generator:
            public Wavy_surface_generator<T,N> {

        private:
            typedef Wavy_surface_generator<T,N> base_type;
            using typename base_type::grid_type;
            using typename base_type::array_type;

        public:
            typedef Wavy_surface_generator<T,N> generator_type;
            typedef std::unique_ptr<generator_type> pointer_type;
            typedef std::vector<pointer_type> container_type;

        private:
            container_type _generators;

        public:

            Irregular_wave_surface_generator() = default;
            Irregular_wave_surface_generator(const Irregular_wave_surface_generator&) = default;
            Irregular_wave_surface_generator&
            operator=(const Irregular_wave_surface_generator&) = default;

            inline explicit
            Irregular_wave_surface_generator(container_type&& generators):
            _generators(std::move(generators)) {}

            inline void
            generate(const grid_type& grid, array_type& result) override {
                result = T(0);
                for (auto& gen : this->_generators) {
                    result += gen->generate(grid);
                }
            };

        };

    }

}

#endif // vim:filetype=cpp