scalar_reference_finite_element.h

#ifndef LF_FE_SCALAR_REFERENCE_FINITE_ELEMENT_H_
#define LF_FE_SCALAR_REFERENCE_FINITE_ELEMENT_H_
 
#include <lf/assemble/assemble.h>
 
namespace lf::fe {
using gdof_idx_t = lf::assemble::gdof_idx_t;
using ldof_idx_t = lf::assemble::ldof_idx_t;
using size_type = lf::assemble::size_type;
using dim_t = lf::assemble::dim_t;
using glb_idx_t = lf::assemble::glb_idx_t;
using sub_idx_t = lf::base::sub_idx_t;
 
template <typename SCALAR>
class ScalarReferenceFiniteElement {
 protected:
  ScalarReferenceFiniteElement() = default;
  ScalarReferenceFiniteElement(const ScalarReferenceFiniteElement&) = default;
  // NOLINTNEXTLINE
  ScalarReferenceFiniteElement(ScalarReferenceFiniteElement&&) noexcept =
      default;
  // NOLINTNEXTLINE
  ScalarReferenceFiniteElement& operator=(const ScalarReferenceFiniteElement&) =
      default;
  // NOLINTNEXTLINE
  ScalarReferenceFiniteElement& operator=(
      ScalarReferenceFiniteElement&&) noexcept = default;
 
 public:
  using Scalar = SCALAR;
 
  virtual ~ScalarReferenceFiniteElement() = default;
 
  [[nodiscard]] virtual base::RefEl RefEl() const = 0;
 
  [[nodiscard]] virtual unsigned int Degree() const = 0;
 
  [[nodiscard]] dim_t Dimension() const { return RefEl().Dimension(); }
 
  [[nodiscard]] virtual size_type NumRefShapeFunctions() const {
    size_type cnt = 0;
    for (dim_t codim = 0; codim <= Dimension(); ++codim) {
      for (sub_idx_t subidx = 0; subidx < RefEl().NumSubEntities(codim);
           ++subidx) {
        cnt += NumRefShapeFunctions(codim, subidx);
      }
    }
    return cnt;
  }
 
  // NOLINTNEXTLINE(misc-unused-parameters)
  [[nodiscard]] virtual size_type NumRefShapeFunctions(dim_t codim) const {
    LF_VERIFY_MSG(false, "Illegal call for non-uniform sub-entity dof numbers");
    return 0;
  }
 
  [[nodiscard]] virtual size_type NumRefShapeFunctions(
      dim_t codim, sub_idx_t subidx) const = 0;
 
  [[nodiscard]] virtual Eigen::Matrix<SCALAR, Eigen::Dynamic, Eigen::Dynamic>
  EvalReferenceShapeFunctions(const Eigen::MatrixXd& refcoords) const = 0;
 
  [[nodiscard]] virtual Eigen::Matrix<SCALAR, Eigen::Dynamic, Eigen::Dynamic>
  GradientsReferenceShapeFunctions(const Eigen::MatrixXd& refcoords) const = 0;
 
  [[nodiscard]] virtual Eigen::MatrixXd EvaluationNodes() const = 0;
 
  [[nodiscard]] virtual size_type NumEvaluationNodes() const = 0;
 
  [[nodiscard]] virtual Eigen::Matrix<SCALAR, 1, Eigen::Dynamic>
  NodalValuesToDofs(
      const Eigen::Matrix<SCALAR, 1, Eigen::Dynamic>& nodvals) const {
    LF_ASSERT_MSG(nodvals.cols() == NumEvaluationNodes(),
                  "nodvals = " << nodvals << " <-> " << NumEvaluationNodes());
    return nodvals;
  }
};
 
template <class SCALAR>
void PrintInfo(std::ostream& o,
               const ScalarReferenceFiniteElement<SCALAR>& srfe,
               unsigned int ctrl = 0) {
  o << typeid(srfe).name() << ", degree = " << srfe.Degree()
    << ", n_rsf = " << srfe.NumRefShapeFunctions()
    << ", n_evln = " << srfe.NumEvaluationNodes();
  if (ctrl > 0) {
    o << "\n evl nodes = " << srfe.EvaluationNodes();
  }
}
 
template <typename SCALAR>
std::ostream& operator<<(std::ostream& o,
                         const ScalarReferenceFiniteElement<SCALAR>& fe_desc) {
  PrintInfo(o, fe_desc, 0);
  return o;
}
 
}  // end namespace lf::fe
 
 
template <class SCALAR>
struct fmt::formatter<lf::fe::ScalarReferenceFiniteElement<SCALAR>>
    : ostream_formatter {};
 
#endif  // LF_FE_SCALAR_REFERENCE_FINITE_ELEMENT_H_