wave_generator.cc

#include <vtestbed/config/real_type.hh>
#include <vtestbed/core/calm_sea_generator.hh>
#include <vtestbed/core/cosine_wave.hh>
#include <vtestbed/core/plain_wave_generator.hh>
#include <vtestbed/core/stokes_wave.hh>
#include <vtestbed/guile/macros.hh>
#include <vtestbed/guile/traits.hh>

using propagating_cosine = vtb::core::Propagating_cosine_wave<VTB_REAL_TYPE,3>;
using standing_cosine = vtb::core::Standing_cosine_wave<VTB_REAL_TYPE,3>;
using propagating_stokes = vtb::core::Propagating_stokes_wave<VTB_REAL_TYPE,3>;
using object_type = std::unique_ptr<vtb::core::Wavy_surface_generator<VTB_REAL_TYPE,3>>;
using traits_type = vtb::guile::Traits<object_type>;

namespace {
    SCM type;
    SCM kw_policy, kw_wave;
    SCM sym_opencl, sym_openmp;
}


namespace vtb {

    namespace guile {

        template <> SCM traits_type::type() { return ::type; }

        inline SCM make_calm_sea_generator() {
            using vtb::core::make_calm_sea_generator;
            using T = VTB_REAL_TYPE;
            return traits_type::make(make_calm_sea_generator<T,3>());
        }

        inline SCM make_plain_wave_generator(SCM rest) {
            using namespace vtb::core;
            using vtb::core::make_plain_wave_generator;
            using T = VTB_REAL_TYPE;
            SCM s_policy = sym_opencl, wave = SCM_UNDEFINED;
            scm_c_bind_keyword_arguments("make-plain-wave-generator", rest,
                                         scm_t_keyword_arguments_flags{},
                                         kw_policy, &s_policy, kw_wave, &wave,
                                         SCM_UNDEFINED);
            Policy policy = Policy::OpenCL;
            if (symbol_equal(s_policy, sym_opencl)) { policy = Policy::OpenCL; }
            else if (symbol_equal(s_policy, sym_openmp)) { policy = Policy::OpenMP; }
            else { throw_error("bad policy"); return SCM_UNSPECIFIED; }
            SCM wave_class = scm_class_of(wave);
            if (wave_class == Traits<propagating_cosine>::type()) {
                auto* wrapper = get_wrapper<propagating_cosine>(wave);
                auto generator = make_plain_wave_generator<T,3>(*wrapper->get(), policy);
                return traits_type::make(std::move(generator));
            }
            if (wave_class == Traits<standing_cosine>::type()) {
                auto* wrapper = get_wrapper<standing_cosine>(wave);
                auto generator = make_plain_wave_generator<T,3>(*wrapper->get(), policy);
                return traits_type::make(std::move(generator));
            }
            if (wave_class == Traits<propagating_stokes>::type()) {
                auto* wrapper = get_wrapper<propagating_stokes>(wave);
                auto generator = make_plain_wave_generator<T,3>(*wrapper->get(), policy);
                return traits_type::make(std::move(generator));
            }
            throw_error("bad wave");
            return SCM_UNSPECIFIED;
        }

        template <> void
        traits_type::define() {
            ::type = define_type<object_type>("<wave-generator>");
            kw_policy = scm_from_utf8_keyword("policy");
            kw_wave = scm_from_utf8_keyword("wave");
            sym_opencl = scm_from_utf8_symbol("opencl");
            sym_openmp = scm_from_utf8_symbol("openmp");
            define_procedure("make-calm-sea-generator", 0, 0, 0,
                             VTB_GUILE_0(make_calm_sea_generator));
            define_procedure("make-plain-wave-generator", 0, 0, 1,
                             VTB_GUILE_1(make_plain_wave_generator));
        }

    }

}