Stokhos_KL_OneDExponentialEigenPair.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//                           Stokhos Package
//
// Copyright 2009 NTESS and the Stokhos contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER

#ifndef STOKHOS_KL_ONE_D_EXPONENTIAL_EIGENPAIR_HPP
#define STOKHOS_KL_ONE_D_EXPONENTIAL_EIGENPAIR_HPP

#include <iostream>
#include <cmath>

#include "Kokkos_Core.hpp"

namespace Stokhos {

  namespace KL {

    template <typename eigen_function_type>
    struct OneDEigenPair {
      typedef typename eigen_function_type::value_type value_type;
      eigen_function_type eig_func;
      value_type eig_val;
    }; // struct OneDEigenPair


    template <typename Value>
    class ExponentialOneDEigenFunction {
    public:

      typedef Value value_type;

      enum TYPE {
        SIN, 
        COS  
      };

      KOKKOS_INLINE_FUNCTION
      ExponentialOneDEigenFunction() :
        type(SIN), a(0), b(0), A(0), omega(0), dim_name(0) {}

      KOKKOS_INLINE_FUNCTION
      ExponentialOneDEigenFunction(TYPE type_, const value_type& a_,
                                   const value_type& b_,
                                   const value_type& omega_,
                                   const int dim_name_) :
        type(type_), a((b_-a_)/2.0), b((b_+a_)/2.0), omega(omega_),
        dim_name(dim_name_) {
        if (type == SIN)
          A = 1.0/std::sqrt(a - std::sin(2.*omega*a)/(2.*omega));
        else
          A = 1.0/std::sqrt(a + std::sin(2.*omega*a)/(2.*omega));
      }

      KOKKOS_INLINE_FUNCTION
      ~ExponentialOneDEigenFunction() {}

      template <typename point_type>
      KOKKOS_INLINE_FUNCTION
      point_type
      evaluate(const point_type& x) const {
        if (type == SIN)
          return A*sin(omega*(x-b));
        return A*cos(omega*(x-b));
      }

      void print(std::ostream& os) const {
        os << A << " * ";
        if (type == SIN)
          os << "sin(";
        else
          os << "cos(";
        os << omega << " * (x_" << dim_name << " - " << b << "))";
      }

      KOKKOS_INLINE_FUNCTION
      TYPE getType() const { return type; }

      KOKKOS_INLINE_FUNCTION
      value_type getFrequency() const { return omega; }

      KOKKOS_INLINE_FUNCTION
      value_type getMultiplier() const { return A; }

      KOKKOS_INLINE_FUNCTION
      value_type getShift() const { return b; }

    protected:

      TYPE type;

      value_type a;

      value_type b;

      value_type A;

      value_type omega;

      int dim_name;
    };

  } // namespace KL

} // namespace Stokhos

#endif // STOKHOS_KL_ONE_D_EXPONENTIALEIGENPAIR_HPP