shallow_water_wave.hh

#ifndef VTESTBED_CORE_SHALLOW_WATER_WAVE_HH
#define VTESTBED_CORE_SHALLOW_WATER_WAVE_HH

#include <vtestbed/base/constants.hh>
#include <vtestbed/core/wave.hh>

namespace vtb {

    namespace core {

        template <class T, int N>
        inline Frequency<T>
        shallow_water_wave_angular_frequency(const blitz::TinyVector<T,N>& k, T depth) {
            using std::sqrt;
            using std::tanh;
            using base::constants;
            constexpr auto g = constants<T>::g();
            const auto k_len = length(k);
            return Frequency<T>{sqrt(g*k_len*tanh(k_len*depth))};
        }

        template <class T, int N>
        inline Frequency<T>
        shallow_water_wave_angular_frequency(
            Length<T> length,
            Direction<T> angle,
            T depth
        ) {
            return shallow_water_wave_angular_frequency<T,N>(
                wave_number<T,N>(length, angle), depth
            );
        }

        template <class T, int N>
        class Shallow_water_wave: public Wave_base<T,N> {

        public:
            using typename Wave_base<T,N>::vec;

            Shallow_water_wave() = default;
            ~Shallow_water_wave() = default;
            Shallow_water_wave(const Shallow_water_wave&) = default;
            Shallow_water_wave& operator=(const Shallow_water_wave&) = default;

            inline
            Shallow_water_wave(Amplitude<T> amplitude, const vec& wave_number, T depth):
            Wave_base<T,N>(
                amplitude,
                wave_number,
                linear_wave_angular_frequency(wave_number, depth)
            ) {}

            inline
            Shallow_water_wave(
                Amplitude<T> amplitude,
                Length<T> length,
                Direction<T> direction,
                T depth
            ):
            Shallow_water_wave(amplitude, wave_number<T,N-1>(length, direction), depth)
            {}

        };

    }

}

#endif // vim:filetype=cpp