statistics.hh

#ifndef VTESTBED_CORE_STATISTICS_HH
#define VTESTBED_CORE_STATISTICS_HH

#include <iosfwd>
#include <utility>

#include <vtestbed/base/blitz.hh>
#include <vtestbed/core/circular_buffer.hh>
#include <vtestbed/core/grid.hh>
#include <vtestbed/core/wave_numbers.hh>

namespace vtb {

    namespace core {

        class Statistics_base {

        public:
            using size_type = std::size_t;
            enum class Record {
                Time = 0,
                Position = 1,
                Euler_angles = 4,
                Velocity = 7,
                Angular_velocity = 10,
                Acceleration = 13,
                Angular_acceleration = 16,
                Underwater_volume = 19,
                Wave_length = 20,
                Wave_number = 23,
                Wave_height = 26,
                Wavy_surface = 29,
                Angular_momentum = 30,
                Number_of_records = 33,
                // aliases for vector components
                Surge = 1, Sway = 2, Heave = 3,
                Roll = 4, Pitch = 5, Yaw = 6,
                Velocity_x = 7, Velocity_y = 8, Velocity_z = 9,
                Angular_velocity_x = 10, Angular_velocity_y = 11, Angular_velocity_z = 12,
                Acceleration_x = 13, Acceleration_y = 14, Acceleration_z = 15,
                Angular_acceleration_x = 16,
                Angular_acceleration_y = 17,
                Angular_acceleration_z = 18,
                Wave_length_t = 20, Wave_length_x = 21, Wave_length_y = 22,
                Wave_number_t = 23, Wave_number_x = 24, Wave_number_y = 25,
                Wave_height_t = 26, Wave_height_x = 27, Wave_height_y = 28,
                Angular_momentum_x = 30, Angular_momentum_y = 31, Angular_momentum_z = 32,
            };


        public:

            static constexpr inline size_type
            size() noexcept {
                return static_cast<size_type>(Record::Number_of_records);
            }

            static void write_header(std::ostream& out);

        };

        template <class T>
        class Statistics: public Statistics_base {

        public:
            using time_series = Circular_buffer<T>;
            using size_type = typename time_series::size_type;
            using pointer = time_series*;
            using const_pointer = const time_series*;
            using reference = time_series&;
            using const_reference = const time_series&;
            using array1 = blitz::Array<T,1>;
            using array2 = blitz::Array<T,2>;
            using grid1 = Grid<T,1>;
            using shape2 = blitz::TinyVector<int,2>;
            using wave_statistics_vector = Wave_statistics_vector<T,3>;

        private:
            time_series _series[size()];
            wave_statistics_vector _waves;

        public:

            inline explicit
            Statistics(size_type n) {
                for (auto& s : this->_series) { s.resize(n); }
            }

            Statistics(Statistics&&) = default;

            Statistics&
            operator=(const Statistics& rhs) = default;

            inline void
            record(Record rec, T value) {
                auto& stats = *this;
                stats[rec].record(value);
            }

            inline void
            record(Record rec, const blitz::TinyVector<T,3>& value) {
                auto& series = this->_series;
                auto i = static_cast<size_type>(rec);
                series[i].record(value(0));
                series[i+1].record(value(1));
                series[i+2].record(value(2));
            }

            inline const_reference
            operator[](Record rec) const {
                return this->_series[static_cast<size_type>(rec)];
            }

            inline reference
            operator[](Record rec) {
                return this->_series[static_cast<size_type>(rec)];
            }

            inline pointer begin() { return this->_series; }
            inline const_pointer begin() const { return this->_series; }
            inline pointer end() { return this->begin() + this->size(); }
            inline const_pointer end() const { return this->begin() + this->size(); }
            inline size_type series_size() const { return this->_series[0].size(); }
            void clear();

            void write_back(std::ostream& out) const;

            inline const_reference
            time_instant_series() const {
                return this->operator[](Record::Time);
            }

            inline const_reference
            wavy_surface_series() const {
                return this->operator[](Record::Wavy_surface);
            }


            inline wave_statistics_vector& waves() { return this->_waves; }
            inline const wave_statistics_vector& waves() const { return this->_waves; }

            void record_waves();

        private:

            auto uniform_wavy_surface() const -> std::pair<array1,grid1>;

        };

    }

}

#endif // vim:filetype=cpp