statistics.cc

#include <ostream>

#include <vtestbed/config/real_type.hh>
#include <vtestbed/core/statistics.hh>
#include <vtestbed/geometry/linear_interpolation.hh>

namespace {

    constexpr const char* headers[vtb::core::Statistics_base::size()] = {
        // please, use lowercase letters
        "time",
        "surge", "sway", "heave",
        "roll", "pitch", "yaw",
        "velocity_x", "velocity_y", "velocity_z",
        "angular_velocity_x", "angular_velocity_y", "angular_velocity_z",
        "acceleration_x", "acceleration_y", "acceleration_z",
        "angular_acceleration_x", "angular_acceleration_y", "angular_acceleration_z",
        "underwater_volume",
        "wave_length_t", "wave_length_x", "wave_length_y",
        "wave_number_t", "wave_number_x", "wave_number_y",
        "wave_height_t", "wave_height_x", "wave_height_y",
        "wavy_surface",
        "angular_momentum_x", "angular_momentum_y", "angular_momentum_z",
    };

    static_assert(vtb::core::Statistics_base::size() > 0 &&
            headers[vtb::core::Statistics_base::size()-1] != 0,
            "add header name");

}

void
vtb::core::Statistics_base::write_header(std::ostream& out) {
    static_assert(size() > 0, "bad no. of records");
    out << headers[0];
    for (size_type i=1; i<size(); ++i){ out << ',' << headers[i]; }
    out << '\n';
}

template <class T>
void
vtb::core::Statistics<T>::write_back(std::ostream& out) const {
    static_assert(size() > 0, "bad no. of records");
    out << this->_series[0].back();
    for (size_type i=1; i<size(); ++i){ out << ',' << this->_series[i].back(); }
    out << '\n';
}

template <class T>
auto
vtb::core::Statistics<T>::uniform_wavy_surface() const
-> std::pair<array1,grid1> {
    using vtb::geometry::Linear_interpolation;
    typedef vtb::geometry::Linear_interpolation<T,2> curve_type;
    typedef typename curve_type::vertex_array vertex_array;
    const auto& t = this->time_instant_series();
    const auto& wss = this->wavy_surface_series();
    array1 result; grid1 grid;
    const int nt = t.size();
    if (nt <= 3) { return std::make_pair(result,grid); }
    const T delta = T{1}/(nt-1);
    vertex_array points;
    points.reserve(nt);
    grid.begin() = 0;
    grid.end() = nt;
    grid.lbound() = t.front();
    grid.ubound() = t.back();
    result.resize(nt);
    points.clear();
    for (auto first = t.cbegin(), last = t.cend(),
        first2 = wss.cbegin(); first != last; ++first, ++first2) {
        points.emplace_back(*first, *first2);
    }
    curve_type curve(points);
    for (int k=0; k<nt; ++k) { result(k) = curve(k*delta)(1); }
    return std::make_pair(result,grid);
}

template <class T>
void vtb::core::Statistics<T>::clear() {
    for (auto& s : this->_series) { s.clear(); }
    for (auto& w : this->_waves) { w.clear(); }
}

template <class T>
void vtb::core::Statistics<T>::record_waves() {
    const auto& pair = this->uniform_wavy_surface();
    this->_waves(0) = temporal_wave_statistics(pair.first, pair.second);
    this->record(Record::Wave_length_t, this->_waves(0).length.mean());
    this->record(Record::Wave_length_x, this->_waves(1).length.mean());
    this->record(Record::Wave_length_y, this->_waves(2).length.mean());
    this->record(Record::Wave_number_t, this->_waves(0).number.mean());
    this->record(Record::Wave_number_x, this->_waves(1).number.mean());
    this->record(Record::Wave_number_y, this->_waves(2).number.mean());
    this->record(Record::Wave_height_t, this->_waves(0).height.mean());
    this->record(Record::Wave_height_x, this->_waves(1).height.mean());
    this->record(Record::Wave_height_y, this->_waves(2).height.mean());
}

template class vtb::core::Statistics<VTB_REAL_TYPE>;