flooding_solver.hh

#ifndef VTESTBED_CORE_FLOODING_SOLVER_HH
#define VTESTBED_CORE_FLOODING_SOLVER_HH

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

namespace vtb {

    namespace core {

        template <class T>
        class Volume {

        private:
            T _volume{};
            Vector<T,3> _point{T{}};

        public:

            Volume() = default;
            inline Volume(T v, const Vector<T,3>& x): _volume(v), _point(x) {}

            inline void
            accumulate(T v, const Vector<T,3>& x) {
                this->_volume += v;
                this->_point += x*v;
            }

            inline void normalise() { this->_point /= this->_volume; }
            inline void clear() { this->_point = 0, this->_volume = 0; }
            inline T volume() const { return this->_volume; }
            inline const Vector<T,3>& point() const { return this->_point; }

        };

        template <class T>
        class Flooding_solver {

        public:
            using polyhedron_type = vtb::geometry::Polyhedron<T,3>;
            using bounds_type = vtb::geometry::Bounds<T>;
            using vertex_type = Vector<T,3>;

        private:
            const polyhedron_type& _polyhedron;
            bounds_type _z_bounds;
            vertex_type _centre{T{}};
            T _volume{};
            T _level{};

        public:

            Flooding_solver(const polyhedron_type& polyhedron);

            void volume(T new_volume);

            void level(T new_level);

            inline const bounds_type& z_bounds() const { return this->_z_bounds; }
            inline const vertex_type& centre_of_mass() const { return this->_centre; }
            inline T volume() const { return this->_volume; }
            inline T level() const { return this->_level; }
            inline const polyhedron_type& polyhedron() const { return this->_polyhedron; }

        private:

            T calc_level();
            Volume<T> calc_volume(T level);

        };

    }

}

#endif // vim:filetype=cpp