LobattoPolynomial.hpp

Go to the documentation of this file.

/** \file LobattoPolynomial.hpp
\brief Implementation of Lobatto polynomials
 
This file provides functions and classes for calculating Lobatto polynomial
basis functions and their derivatives for use in finite element approximations.
Lobatto polynomials are particularly useful for spectral and high-order methods.
 
*/
 
 
 
#ifndef __LOBATTOPOLYNOMIALS_HPP__
#define __LOBATTOPOLYNOMIALS_HPP__
 
namespace MoFEM {
 
 
/**
 \brief Calculate Lobatto basis functions \cite FUENTES2015353.
 
 \ingroup mofem_base_functions
 
 Lobatto polynomials are hierarchical basis functions that include vertex modes
 and edge/internal modes. They are constructed from Legendre polynomials and 
 provide excellent conditioning properties for high-order finite element methods.
 
 The first function corresponds to order 2 and the sequence continues up to order p.
 These polynomials are particularly useful for spectral element methods due to
 their orthogonality properties on the reference interval [-1,1].
 
 For more information on Lobatto polynomials, see:
 https://en.wikipedia.org/wiki/Gauss%E2%80%93Lobatto_quadrature
 
 \param p approximation order (maximum polynomial degree)
 \param s coordinate mapping from edge to \f$[-1, 1]\f$, i.e., \f$s(\xi_1,\cdot,\xi_{dim})\in[-1,1]\f$
 \param diff_s [in] Jacobian of the coordinate transformation, i.e. \f$\frac{\partial s}{\partial \xi_i}\f$ 
 \param L [out] values of basis functions evaluated at coordinate s 
 \param diffL [out] derivatives of basis functions at s, i.e. \f$\frac{\partial L}{\partial \xi_i}\f$ 
 \param dim spatial dimension
 \return PetscErrorCode indicating success or failure
 
 \note Output arrays L and diffL must be pre-allocated with sufficient size
*/    
PetscErrorCode Lobatto_polynomials(int p, double s, double *diff_s, double *L,
                                   double *diffL, const int dim);  
 
/**
 * \brief Context class for Lobatto basis function arguments
 * \ingroup mofem_base_functions
 * 
 * This class extends LegendrePolynomialCtx to provide context for evaluating
 * Lobatto polynomial basis functions. It inherits all functionality from the
 * Legendre context and specializes the polynomial evaluation function.
 */
struct LobattoPolynomialCtx : public LegendrePolynomialCtx {
 
  MoFEMErrorCode query_interface(boost::typeindex::type_index type_index,
                                 UnknownInterface **iface) const;
 
  /**
   * \brief Constructor
   * \param p approximation order
   * \param diff_s derivatives of coordinate parameter
   * \param dim spatial dimension
   * \param base_fun_ptr pointer to base function matrix
   * \param base_diff_fun_ptr pointer to base function derivatives matrix
   */
  LobattoPolynomialCtx(int p, double *diff_s, int dim,
                       boost::shared_ptr<MatrixDouble> base_fun_ptr,
                       boost::shared_ptr<MatrixDouble> base_diff_fun_ptr)
      : LegendrePolynomialCtx(p, diff_s, dim, base_fun_ptr, base_diff_fun_ptr) {
    basePolynomialsType0 = Lobatto_polynomials;
  }
  ~LobattoPolynomialCtx() {}
};
 
/**
 * \brief Class for calculating Lobatto basis functions
 * \ingroup mofem_base_functions
 * 
 * This class extends LegendrePolynomial to provide Lobatto polynomial
 * evaluation capabilities. Lobatto polynomials are hierarchical basis
 * functions that include both vertex and higher-order modes, making them
 * ideal for spectral and high-order finite element methods.
 */
struct LobattoPolynomial : public LegendrePolynomial {
 
  MoFEMErrorCode query_interface(boost::typeindex::type_index type_index,
                                 UnknownInterface **iface) const;
 
  LobattoPolynomial() {}
  ~LobattoPolynomial() {}
 
  /**
   * \brief Evaluate Lobatto basis functions at given points
   * \param pts matrix of evaluation points
   * \param ctx_ptr context containing evaluation parameters
   * \return error code
   */
  MoFEMErrorCode getValue(MatrixDouble &pts,
                          boost::shared_ptr<BaseFunctionCtx> ctx_ptr);
};
 
/**
 * \brief Context class for Kernel Lobatto basis function arguments
 * \ingroup mofem_base_functions
 * 
 * This class provides context for evaluating Kernel Lobatto polynomial basis
 * functions. Kernel Lobatto polynomials are a variant that may have different
 * orthogonality or boundary conditions compared to standard Lobatto polynomials.
 */
struct KernelLobattoPolynomialCtx : public LegendrePolynomialCtx {
 
  MoFEMErrorCode query_interface(boost::typeindex::type_index type_index,
                                 UnknownInterface **iface) const;
 
  /**
   * \brief Constructor
   * \param p approximation order
   * \param diff_s derivatives of coordinate parameter
   * \param dim spatial dimension
   * \param base_fun_ptr pointer to base function matrix
   * \param base_diff_fun_ptr pointer to base function derivatives matrix
   */
  KernelLobattoPolynomialCtx(int p, double *diff_s, int dim,
                             boost::shared_ptr<MatrixDouble> base_fun_ptr,
                             boost::shared_ptr<MatrixDouble> base_diff_fun_ptr)
      : LegendrePolynomialCtx(p, diff_s, dim, base_fun_ptr, base_diff_fun_ptr) {
    basePolynomialsType0 = LobattoKernel_polynomials;
  }
  ~KernelLobattoPolynomialCtx() {}
};
 
/**
 * \brief Class for calculating Kernel Lobatto basis functions
 * \ingroup mofem_base_functions
 * 
 * This class extends LegendrePolynomial to provide Kernel Lobatto polynomial
 * evaluation capabilities. Kernel Lobatto polynomials are a specialized variant
 * that may be used for specific boundary conditions or integration schemes.
 */
struct KernelLobattoPolynomial : public LegendrePolynomial {
 
  MoFEMErrorCode query_interface(boost::typeindex::type_index type_index,
                                 UnknownInterface **iface) const;
 
  KernelLobattoPolynomial() {}
  ~KernelLobattoPolynomial() {}
 
  /**
   * \brief Evaluate Kernel Lobatto basis functions at given points
   * \param pts matrix of evaluation points
   * \param ctx_ptr context containing evaluation parameters
   * \return error code
   */
  MoFEMErrorCode getValue(MatrixDouble &pts,
                          boost::shared_ptr<BaseFunctionCtx> ctx_ptr);
};
 
} // namespace MoFEM
 
#endif