arma_wind_solver.hh

#ifndef VTESTBED_CORE_ARMA_WIND_SOLVER_HH
#define VTESTBED_CORE_ARMA_WIND_SOLVER_HH

#include <memory>
#include <vector>

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

namespace vtb {

    namespace core {

        template <class T>
        class ARMA_wind_solver {

        public:
            using array_type = Array<T,4>;
            using generator_type = Wind_generator<T>;
            using wind_field_type = Array<blitz::TinyVector<T,3>, 3>;
            using grid_type = Grid<T,4>;
            using shape_type = blitz::TinyVector<int,4>;
            using panel_type = Ship_hull_panel<T,3>;
            using panel_array = Array<panel_type,1>;

        private:
            T _c1, _c2;
            T _sigma;
            grid_type _grid;
            shape_type _order;
            std::vector<generator_type> _wind_generators;
            std::vector<Wind_param<T>> _params;
            wind_field_type _wind_field;

        public:

            inline
            ARMA_wind_solver() {
                for (int i = 0; i < 3; i++) {
                    _wind_generators.push_back(generator_type());
                    _params.push_back(Wind_param<T>());
                }
            }

            ~ARMA_wind_solver() = default;

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

            void step(panel_array panels);

            void initialize();

            inline void
            setGrid(const grid_type& grid) {
                for (int i=0; i<3; ++i) {
                    _params[i]._grid = grid;
                }
            }

            inline const grid_type& grid() const { return _params[0]._grid; }

            inline void
            setSigma(T sigma) {
                for (int i=0; i<3; ++i) {
                    _params[i]._sigma = sigma;
                }
            }

            inline T sigma() const { return _params[0]._sigma; }
            inline void setC1(T c1, int ext) { _params[ext]._c1 = c1; }
            inline T c1(int ext) { return _params[ext]._c1; }
            inline void setC2(T c2, int ext) { _params[ext]._c2 = c2; }
            inline T c2(int ext) { return _params[ext]._c2; }

            inline void
            setOrder(shape_type order) {
                for (int i=0; i<3; ++i) {
                    _params[i]._order = order;
                }
            }

            inline const shape_type& order() const { return _params[0]._order; }

        };

    }

}

#endif // vim:filetype=cpp