velocity_function.hpp

Go to the documentation of this file.

#pragma once

#include <cmath>
#include <tuple>
#include <cassert>

namespace LCS {
namespace VelocityFunction {

template <typename T>
struct BowerModel
{
    BowerModel(): sc_(50), a_(50), l_(400), cx_(10), lambda_(40) {}

    BowerModel(std::vector<T>& p)
    {
        assert(p.size() == 5);
        sc_ = p[0]; a_ = p[1]; l_ = p[2]; cx_ = p[3]; lambda_ = p[4];
    }

    inline auto operator() (const T x, const T y, const T t = 0) const
    {

        T phi0 = sc_ * lambda_; // scale factor
        T k = 8 * std::atan(1) / l_; // wave number (2*pi/L)

        T yc = a_ * std::sin(k * x);
        T dyc = a_ * k * std::cos(k * x);
        T alpha0 = lambda_ * std::sqrt(dyc*dyc + 1);

        T u = -cx_ + phi0 / std::pow(std::cosh((y-yc)/alpha0), 2) / alpha0;
        T v = -phi0 * ((yc*dyc*k*k*(y-yc)) / (lambda_*std::pow(dyc*dyc+1,1.5)) - dyc/alpha0)
            / std::pow(std::cosh((y-yc)/alpha0), 2);

        return std::make_tuple(u, v);
    }

    T sc_; 
    T a_; 
    T l_; 
    T cx_; 
    T lambda_; 
};


template <typename T>
struct DoubleGyreModel
{
    DoubleGyreModel(): epsilon_(0.1), a_(0.1), omega_(4*std::atan(1)/5) {}

    DoubleGyreModel(std::vector<T>& p)
    {
        assert(p.size() == 3);
        epsilon_ = p[0]; a_ = p[1]; omega_ = p[2];
    }

    inline auto operator() (const T x, const T y, const T t) const
    {
        T at = epsilon_ * std::sin(omega_ * t);
        T bt = 1 - 2 * epsilon_ * std::sin(omega_ * t);
        T f = at*x*x + bt*x;
        T dfdx = 2*at*x + bt;

        T pi = 4 * std::atan(1);
        T u = -pi * a_ * std::sin(pi*f) * std::cos(pi*y);
        T v = pi * a_ * std::cos(pi*f) * std::sin(pi*y) * dfdx;

        return std::make_tuple(u, v);
    }

    T epsilon_; 
    T a_; 
    T omega_; 
};


}
}