linear_wave.hh

#ifndef VTESTBED_CORE_LINEAR_WAVE_HH
#define VTESTBED_CORE_LINEAR_WAVE_HH

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

namespace vtb {

    namespace core {

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

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

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

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

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

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

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

            inline T
            operator()(const vec& x, T t) const noexcept {
                using blitz::dot;
                using std::cos;
                return this->amplitude() *
                    cos(dot(this->wave_number(), x) - this->angular_frequency()*t);
            }

        };

    }

}

#endif // vim:filetype=cpp