compartment.hh

#ifndef VTESTBED_CORE_COMPARTMENT_HH
#define VTESTBED_CORE_COMPARTMENT_HH

#include <iosfwd>
#include <string>
#include <vector>

#include <vtestbed/base/constants.hh>
#include <vtestbed/core/types.hh>
#include <vtestbed/geometry/polyhedron.hh>


namespace vtb {

    namespace core {

        template <class T>
        class Compartment {

        public:
            using vec3 = Vector3<T>;
            using face_type = vtb::geometry::Face<3>;
            using face_array = Array<face_type,1>;
            using polyhedron_type = vtb::geometry::Polyhedron<T,3>;

        private:
            polyhedron_type _polyhedron;
            T _flooded_volume{};
            vec3 _centre{T{}};
            std::string _name;
            bool _fire = false;

        public:

            inline const std::string& name() const { return this->_name; }
            inline void name(const std::string& rhs) { this->_name = rhs; }
            inline const polyhedron_type& polyhedron() const { return this->_polyhedron; }
            inline void polyhedron(const polyhedron_type& rhs) { this->_polyhedron = rhs; }
            inline void polyhedron(polyhedron_type&& rhs) { this->_polyhedron = std::move(rhs); }
            inline T flooded_volume() const { return this->_flooded_volume; }
            T flooded_volume(T rhs);
            inline void fire(bool rhs) { this->_fire = rhs; }
            inline bool fire() const { return this->_fire; }
            inline bool flooding() const { return this->_flooded_volume > 0; }
            inline const vec3& flooded_mass_centre() const { return this->_centre; }
            void calc_flooded_mass_centre();

            inline T
            flooded_mass() const {
                using constants = base::constants<T>;
                return this->_flooded_volume*constants::water_density();
            }

            void box(const vec3& x0, const vec3& x1);

            template <class X>
            friend std::ostream&
            operator<<(std::ostream& out, const Compartment<X>& rhs);

        };

        template <class T>
        std::ostream&
        operator<<(std::ostream& out, const Compartment<T>& rhs);

        template <class T>
        class Compartment_array: public std::vector<Compartment<T>> {

        private:
            using base_type = std::vector<Compartment<T>>;
            using polyhedron_type = typename Compartment<T>::polyhedron_type;

        public:
            using value_type = typename base_type::value_type;
            using pointer = typename base_type::pointer;
            using const_pointer = typename base_type::const_pointer;
            using reference = typename base_type::reference;
            using const_reference = typename base_type::const_reference;
            using iterator = typename base_type::iterator;
            using const_iterator = typename base_type::const_iterator;
            using size_type = typename base_type::size_type;
            using difference_type = typename base_type::difference_type;
            using reverse_iterator = typename base_type::reverse_iterator;
            using const_reverse_iterator = typename base_type::const_reverse_iterator;

        public:

            using base_type::base_type;
            using base_type::operator=;
            using base_type::operator[];

            auto find(const std::string& name) -> iterator;

            static Compartment_array
            generate(const polyhedron_type& hull, const int3& nrooms);

        };

    }

}

#endif // vim:filetype=cpp