plain_wave_generator_openmp.cc

#include <vtestbed/config/real_type.hh>
#include <vtestbed/config/openmp.hh>
#include <vtestbed/core/cosine_wave.hh>
#include <vtestbed/core/stokes_wave.hh>
#include <vtestbed/core/plain_wave_generator.hh>

namespace vtb {

    namespace core {

        template <class T, int N, class Wave>
        class Plain_wave_generator_openmp:
            public Plain_wave_generator<T,N,Wave,Policy::OpenMP> {

        private:
            using base_type = Plain_wave_generator<T,N,Wave,Policy::OpenMP>;
            using typename base_type::grid_type;
            using typename base_type::array_type;

        public:
            using base_type::base_type;

            void generate(const grid_type& grid, array_type& result) override {
                generate_wave<T,N,Wave>(grid, result, this->wave());
            }

        };

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

    }

}

#define VTB_MAKE_PLAIN_WAVE_SURFACE_GENERATOR(T,N,Wave) \
template <> \
auto \
vtb::core::make_plain_wave_generator(const Wave<T,N>& wave) \
-> std::unique_ptr<Plain_wave_generator<T,N,Wave<T,N>,Policy::OpenMP>> { \
    return std::unique_ptr<Plain_wave_generator<T,N,Wave<T,N>,Policy::OpenMP>>( \
        new Plain_wave_generator_openmp<T,N,Wave<T,N>>(wave) \
    ); \
} \
template <> \
auto \
vtb::core::make_plain_wave_generator() \
-> std::unique_ptr<Plain_wave_generator<T,N,Wave<T,N>,Policy::OpenMP>> { \
    return std::unique_ptr<Plain_wave_generator<T,N,Wave<T,N>,Policy::OpenMP>>( \
        new Plain_wave_generator_openmp<T,N,Wave<T,N>>() \
    ); \
}

VTB_MAKE_PLAIN_WAVE_SURFACE_GENERATOR(VTB_REAL_TYPE,3,vtb::core::Propagating_cosine_wave)
VTB_MAKE_PLAIN_WAVE_SURFACE_GENERATOR(VTB_REAL_TYPE,3,vtb::core::Standing_cosine_wave)
VTB_MAKE_PLAIN_WAVE_SURFACE_GENERATOR(VTB_REAL_TYPE,3,vtb::core::Propagating_stokes_wave)
#if defined(VTB_REAL_TYPE_FLOAT)
VTB_MAKE_PLAIN_WAVE_SURFACE_GENERATOR(double,3,vtb::core::Propagating_cosine_wave);
VTB_MAKE_PLAIN_WAVE_SURFACE_GENERATOR(double,3,vtb::core::Standing_cosine_wave);
VTB_MAKE_PLAIN_WAVE_SURFACE_GENERATOR(double,3,vtb::core::Propagating_stokes_wave);
#endif

template <class T, int N>
std::unique_ptr<vtb::core::Wavy_surface_generator<T,N>>
vtb::core::make_plain_wave_generator_openmp(std::any wave) {
    using pointer = std::unique_ptr<Wavy_surface_generator<T,N>>;
    using propagating_cosine = Propagating_cosine_wave<T,N>;
    using standing_cosine = Standing_cosine_wave<T,N>;
    using propagating_stokes = Propagating_stokes_wave<T,N>;
    if (wave.type() == typeid(propagating_cosine)) {
        return pointer(new Plain_wave_generator_openmp<T,N,propagating_cosine>(
                std::any_cast<propagating_cosine>(wave)));
    }
    if (wave.type() == typeid(standing_cosine)) {
        return pointer(new Plain_wave_generator_openmp<T,N,standing_cosine>(
                std::any_cast<standing_cosine>(wave)));
    }
    if (wave.type() == typeid(propagating_stokes)) {
        return pointer(new Plain_wave_generator_openmp<T,N,propagating_stokes>(
                std::any_cast<propagating_stokes>(wave)));
    }
    throw std::invalid_argument("bad wave");
}

template std::unique_ptr<vtb::core::Wavy_surface_generator<VTB_REAL_TYPE,3>>
vtb::core::make_plain_wave_generator_openmp<VTB_REAL_TYPE,3>(std::any wave);
#if defined(VTB_REAL_TYPE_FLOAT)
template std::unique_ptr<vtb::core::Wavy_surface_generator<double,3>>
vtb::core::make_plain_wave_generator_openmp<double,3>(std::any wave);
#endif