gerstner.hh

#ifndef VTESTBED_CORE_GERSTNER_HH
#define VTESTBED_CORE_GERSTNER_HH

#include <vector>

#include <vtestbed/core/linear_wave.hh>
#include <vtestbed/core/policy.hh>
#include <vtestbed/core/ship.hh>
#include <vtestbed/core/ship_hull_panel.hh>
#include <vtestbed/core/types.hh>
#include <vtestbed/core/wave.hh>
#include <vtestbed/core/wavy_surface_generator.hh>
#include <vtestbed/geometry/types.hh>

namespace vtb {

    namespace core {

        template <class T, int N>
        class Gerstner_solver {

        public:
            using scalar_type = T;
            using vertex_type = blitz::TinyVector<T,N>;
            using vertex_field_3d = Array<vertex_type,3>;
            using scalar_field_3d = Array<T,3>;
            using grid3 = Grid<T,N>;
            using grid4 = Grid<T,N+1>;
            using panel_type = Ship_hull_panel<T,N>;
            using panel_array = std::vector<panel_type>;
            using wave_type = Linear_wave<T,N>;
            using wave_array = std::vector<wave_type>;
            using ship_type = Ship<T>;
            using C = std::complex<T>;

        protected:
            T _depth = std::numeric_limits<T>::infinity();
            wave_array _waves{{Amplitude<T>(1),Length<T>(40),Direction<T>(0)}};
            vertex_field_3d _velocity;
            scalar_field_3d _potential;
            grid3 _velocity_grid_zxy;
            panel_array _old_panels;
            T _old_t{};
            bool _diffraction = false;
            bool _radiation = false;
            bool _waterline_only = true;
            bool _clip = true;

        public:

            inline T depth() const { return this->_depth; }
            inline void depth(T rhs) { this->_depth = rhs; }

            inline const wave_array& waves() const { return this->_waves; }
            inline void waves(wave_array&& rhs) { this->_waves = std::move(rhs); }
            inline void waves(const wave_array& rhs) { this->_waves = rhs; }

            inline bool diffraction() const { return this->_diffraction; }
            inline void diffraction(bool rhs) { this->_diffraction = rhs; }

            inline bool radiation() const { return this->_radiation; }
            inline void radiation(bool rhs) { this->_radiation = rhs; }

            inline bool waterline_only() const { return this->_waterline_only; }
            inline void waterline_only(bool rhs) { this->_waterline_only = rhs; }

            inline bool clip() const { return this->_clip; }
            inline void clip(bool rhs) { this->_clip = rhs; }

            virtual void
            compute_positions(
                const ship_type& ship,
                const panel_array& panels,
                const grid3& grid_txy,
                vertex_field_3d& surface
            ) = 0;

            virtual void
            compute_forces(
                const ship_type& ship,
                const grid4& grid_tzxy,
                panel_array & wetted_panels
            ) = 0;

            inline const vertex_field_3d& velocity() const { return this->_velocity; }
            inline const scalar_field_3d& potential() const { return this->_potential; }
            inline const grid3& velocity_grid() const { return this->_velocity_grid_zxy; }

            Gerstner_solver() = default;
            virtual ~Gerstner_solver() = default;
            Gerstner_solver(const Gerstner_solver&) = default;
            Gerstner_solver& operator=(const Gerstner_solver&) = default;
            Gerstner_solver(Gerstner_solver&&) = default;
            Gerstner_solver& operator=(Gerstner_solver&&) = default;

        };

        template <class T, int N, Policy P>
        std::unique_ptr<Gerstner_solver<T,N>>
        make_gerstner_solver();

        template <class T, int N>
        std::unique_ptr<Gerstner_solver<T,N>>
        make_gerstner_solver(Policy policy);

    }
}

#endif // vim:filetype=cpp