cosine_wave.hh

#ifndef VTESTBED_CORE_COSINE_WAVE_HH
#define VTESTBED_CORE_COSINE_WAVE_HH

#include <vtestbed/core/linear_wave.hh>

namespace vtb {

    namespace core {

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

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

        public:

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

            inline
            Propagating_cosine_wave(Amplitude<T> amplitude, const vec& k):
            Linear_wave<T,N>(amplitude, k) {}

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

            using Linear_wave<T,N>::operator();

            inline Grid<T,3>
            acf_grid() const {
                throw std::runtime_error("not implemented");
            }

        };

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

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

        public:

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

            inline
            Standing_cosine_wave(Amplitude<T> amplitude, const vec& k):
            Linear_wave<T,N>{amplitude, k} {}

            inline
            Standing_cosine_wave(
                Amplitude<T> amplitude,
                Length<T> length,
                Direction<T> direction
            ): Linear_wave<T,N>{amplitude, 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))
                    * cos(this->angular_frequency()*t);
            }

            T
            velocity_potential(const vec& x, T t, T z);

            vec
            max_velocity() const;

            Grid<T,3>
            acf_grid() const;

        };

    }

}

#endif // vim:filetype=cpp