anlt_wind_solver.hh

#ifndef VTESTBED_CORE_ANLT_WIND_SOLVER_HH
#define VTESTBED_CORE_ANLT_WIND_SOLVER_HH

#include <memory>
#include <vector>

#include <vtestbed/core/types.hh>
#include <vtestbed/geometry/polyline.hh>
#include <vtestbed/geometry/ray.hh>
#include <vtestbed/geometry/types.hh>

namespace vtb {

    namespace core {

        template <class T>
        class ANLT_wind_solver {

        public:
            using array_type = Array<T,4>;
            using vec3 = blitz::TinyVector<T,3>;
            using wind_field_type = Array<vec3,3>;
            using grid_type = Grid<T,3>;
            using panel_type = Ship_hull_panel<T,3>;
            using panel_array = std::vector<panel_type>;
            using ray_type = vtb::geometry::Ray<T,3>;
            using ray_array = vtb::geometry::Ray_array<T,3>;

        protected:
            wind_field_type _wind_field;
            ray_array _wind_field_boundary;
            bool _on_the_boundary = true;
            bool _near_the_boundary = false;
            bool _stratification = false;

        public:

            ANLT_wind_solver() = default;
            virtual ~ANLT_wind_solver() = default;

            inline wind_field_type& wind_field() { return this->_wind_field; }
            inline const wind_field_type& wind_field() const { return this->_wind_field; }

            inline bool on_the_boundary() const { return this->_on_the_boundary; }
            inline void on_the_boundary(bool rhs) { this->_on_the_boundary = rhs; }

            inline bool near_the_boundary() const { return this->_near_the_boundary; }
            inline void near_the_boundary(bool rhs) { this->_near_the_boundary = rhs; }

            inline bool stratification() const { return this->_stratification; }
            inline void stratification(bool rhs) { this->_stratification = rhs; }

            inline const ray_array&
            wind_field_boundary() const {
                return this->_wind_field_boundary;
            }

            virtual void step(const grid_type& grid, panel_array& panels) = 0;
        };

        template <class T, Policy P>
        std::unique_ptr<ANLT_wind_solver<T>>
        make_anlt_wind_solver();

    }

}

#endif // vim:filetype=cpp